/*!
 * Flickity PACKAGED v2.0.2
 * Touch, responsive, flickable carousels
 *
 * Licensed GPLv3 for open source use
 * or Flickity Commercial License for commercial use
 *
 * http://flickity.metafizzy.co
 * Copyright 2016 Metafizzy
 */

/**
 * Bridget makes jQuery widgets
 * v2.0.0
 * MIT license
 */

/* jshint browser: true, strict: true, undef: true, unused: true */

( function( window, factory ) {
    'use strict';
    /* globals define: false, module: false, require: false */

    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'jquery-bridget/jquery-bridget',[ 'jquery' ], function( jQuery ) {
            factory( window, jQuery );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('jquery')
        );
    } else {
        // browser global
        window.jQueryBridget = factory(
            window,
            window.jQuery
        );
    }

}( window, function factory( window, jQuery ) {
    'use strict';

// ----- utils ----- //

    var arraySlice = Array.prototype.slice;

// helper function for logging errors
// $.error breaks jQuery chaining
    var console = window.console;
    var logError = typeof console == 'undefined' ? function() {} :
        function( message ) {
            console.error( message );
        };

// ----- jQueryBridget ----- //

    function jQueryBridget( namespace, PluginClass, $ ) {
        $ = $ || jQuery || window.jQuery;
        if ( !$ ) {
            return;
        }

        // add option method -> $().plugin('option', {...})
        if ( !PluginClass.prototype.option ) {
            // option setter
            PluginClass.prototype.option = function( opts ) {
                // bail out if not an object
                if ( !$.isPlainObject( opts ) ){
                    return;
                }
                this.options = $.extend( true, this.options, opts );
            };
        }

        // make jQuery plugin
        $.fn[ namespace ] = function( arg0 /*, arg1 */ ) {
            if ( typeof arg0 == 'string' ) {
                // method call $().plugin( 'methodName', { options } )
                // shift arguments by 1
                var args = arraySlice.call( arguments, 1 );
                return methodCall( this, arg0, args );
            }
            // just $().plugin({ options })
            plainCall( this, arg0 );
            return this;
        };

        // $().plugin('methodName')
        function methodCall( $elems, methodName, args ) {
            var returnValue;
            var pluginMethodStr = '$().' + namespace + '("' + methodName + '")';

            $elems.each( function( i, elem ) {
                // get instance
                var instance = $.data( elem, namespace );
                if ( !instance ) {
                    logError( namespace + ' not initialized. Cannot call methods, i.e. ' +
                        pluginMethodStr );
                    return;
                }

                var method = instance[ methodName ];
                if ( !method || methodName.charAt(0) == '_' ) {
                    logError( pluginMethodStr + ' is not a valid method' );
                    return;
                }

                // apply method, get return value
                var value = method.apply( instance, args );
                // set return value if value is returned, use only first value
                returnValue = returnValue === undefined ? value : returnValue;
            });

            return returnValue !== undefined ? returnValue : $elems;
        }

        function plainCall( $elems, options ) {
            $elems.each( function( i, elem ) {
                var instance = $.data( elem, namespace );
                if ( instance ) {
                    // set options & init
                    instance.option( options );
                    instance._init();
                } else {
                    // initialize new instance
                    instance = new PluginClass( elem, options );
                    $.data( elem, namespace, instance );
                }
            });
        }

        updateJQuery( $ );

    }

// ----- updateJQuery ----- //

// set $.bridget for v1 backwards compatibility
    function updateJQuery( $ ) {
        if ( !$ || ( $ && $.bridget ) ) {
            return;
        }
        $.bridget = jQueryBridget;
    }

    updateJQuery( jQuery || window.jQuery );

// -----  ----- //

    return jQueryBridget;

}));

/**
 * EvEmitter v1.0.3
 * Lil' event emitter
 * MIT License
 */

/* jshint unused: true, undef: true, strict: true */

( function( global, factory ) {
    // universal module definition
    /* jshint strict: false */ /* globals define, module, window */
    if ( typeof define == 'function' && define.amd ) {
        // AMD - RequireJS
        define( 'ev-emitter/ev-emitter',factory );
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS - Browserify, Webpack
        module.exports = factory();
    } else {
        // Browser globals
        global.EvEmitter = factory();
    }

}( typeof window != 'undefined' ? window : this, function() {



    function EvEmitter() {}

    var proto = EvEmitter.prototype;

    proto.on = function( eventName, listener ) {
        if ( !eventName || !listener ) {
            return;
        }
        // set events hash
        var events = this._events = this._events || {};
        // set listeners array
        var listeners = events[ eventName ] = events[ eventName ] || [];
        // only add once
        if ( listeners.indexOf( listener ) == -1 ) {
            listeners.push( listener );
        }

        return this;
    };

    proto.once = function( eventName, listener ) {
        if ( !eventName || !listener ) {
            return;
        }
        // add event
        this.on( eventName, listener );
        // set once flag
        // set onceEvents hash
        var onceEvents = this._onceEvents = this._onceEvents || {};
        // set onceListeners object
        var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {};
        // set flag
        onceListeners[ listener ] = true;

        return this;
    };

    proto.off = function( eventName, listener ) {
        var listeners = this._events && this._events[ eventName ];
        if ( !listeners || !listeners.length ) {
            return;
        }
        var index = listeners.indexOf( listener );
        if ( index != -1 ) {
            listeners.splice( index, 1 );
        }

        return this;
    };

    proto.emitEvent = function( eventName, args ) {
        var listeners = this._events && this._events[ eventName ];
        if ( !listeners || !listeners.length ) {
            return;
        }
        var i = 0;
        var listener = listeners[i];
        args = args || [];
        // once stuff
        var onceListeners = this._onceEvents && this._onceEvents[ eventName ];

        while ( listener ) {
            var isOnce = onceListeners && onceListeners[ listener ];
            if ( isOnce ) {
                // remove listener
                // remove before trigger to prevent recursion
                this.off( eventName, listener );
                // unset once flag
                delete onceListeners[ listener ];
            }
            // trigger listener
            listener.apply( this, args );
            // get next listener
            i += isOnce ? 0 : 1;
            listener = listeners[i];
        }

        return this;
    };

    return EvEmitter;

}));

/*!
 * getSize v2.0.2
 * measure size of elements
 * MIT license
 */

/*jshint browser: true, strict: true, undef: true, unused: true */
/*global define: false, module: false, console: false */

( function( window, factory ) {
    'use strict';

    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'get-size/get-size',[],function() {
            return factory();
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory();
    } else {
        // browser global
        window.getSize = factory();
    }

})( window, function factory() {
    'use strict';

// -------------------------- helpers -------------------------- //

// get a number from a string, not a percentage
    function getStyleSize( value ) {
        var num = parseFloat( value );
        // not a percent like '100%', and a number
        var isValid = value.indexOf('%') == -1 && !isNaN( num );
        return isValid && num;
    }

    function noop() {}

    var logError = typeof console == 'undefined' ? noop :
        function( message ) {
            console.error( message );
        };

// -------------------------- measurements -------------------------- //

    var measurements = [
        'paddingLeft',
        'paddingRight',
        'paddingTop',
        'paddingBottom',
        'marginLeft',
        'marginRight',
        'marginTop',
        'marginBottom',
        'borderLeftWidth',
        'borderRightWidth',
        'borderTopWidth',
        'borderBottomWidth'
    ];

    var measurementsLength = measurements.length;

    function getZeroSize() {
        var size = {
            width: 0,
            height: 0,
            innerWidth: 0,
            innerHeight: 0,
            outerWidth: 0,
            outerHeight: 0
        };
        for ( var i=0; i < measurementsLength; i++ ) {
            var measurement = measurements[i];
            size[ measurement ] = 0;
        }
        return size;
    }

// -------------------------- getStyle -------------------------- //

    /**
     * getStyle, get style of element, check for Firefox bug
     * https://bugzilla.mozilla.org/show_bug.cgi?id=548397
     */
    function getStyle( elem ) {
        var style = getComputedStyle( elem );
        if ( !style ) {
            logError( 'Style returned ' + style +
                '. Are you running this code in a hidden iframe on Firefox? ' +
                'See http://bit.ly/getsizebug1' );
        }
        return style;
    }

// -------------------------- setup -------------------------- //

    var isSetup = false;

    var isBoxSizeOuter;

    /**
     * setup
     * check isBoxSizerOuter
     * do on first getSize() rather than on page load for Firefox bug
     */
    function setup() {
        // setup once
        if ( isSetup ) {
            return;
        }
        isSetup = true;

        // -------------------------- box sizing -------------------------- //

        /**
         * WebKit measures the outer-width on style.width on border-box elems
         * IE & Firefox<29 measures the inner-width
         */
        var div = document.createElement('div');
        div.style.width = '200px';
        div.style.padding = '1px 2px 3px 4px';
        div.style.borderStyle = 'solid';
        div.style.borderWidth = '1px 2px 3px 4px';
        div.style.boxSizing = 'border-box';

        var body = document.body || document.documentElement;
        body.appendChild( div );
        var style = getStyle( div );

        getSize.isBoxSizeOuter = isBoxSizeOuter = getStyleSize( style.width ) == 200;
        body.removeChild( div );

    }

// -------------------------- getSize -------------------------- //

    function getSize( elem ) {
        setup();

        // use querySeletor if elem is string
        if ( typeof elem == 'string' ) {
            elem = document.querySelector( elem );
        }

        // do not proceed on non-objects
        if ( !elem || typeof elem != 'object' || !elem.nodeType ) {
            return;
        }

        var style = getStyle( elem );

        // if hidden, everything is 0
        if ( style.display == 'none' ) {
            return getZeroSize();
        }

        var size = {};
        size.width = elem.offsetWidth;
        size.height = elem.offsetHeight;

        var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';

        // get all measurements
        for ( var i=0; i < measurementsLength; i++ ) {
            var measurement = measurements[i];
            var value = style[ measurement ];
            var num = parseFloat( value );
            // any 'auto', 'medium' value will be 0
            size[ measurement ] = !isNaN( num ) ? num : 0;
        }

        var paddingWidth = size.paddingLeft + size.paddingRight;
        var paddingHeight = size.paddingTop + size.paddingBottom;
        var marginWidth = size.marginLeft + size.marginRight;
        var marginHeight = size.marginTop + size.marginBottom;
        var borderWidth = size.borderLeftWidth + size.borderRightWidth;
        var borderHeight = size.borderTopWidth + size.borderBottomWidth;

        var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;

        // overwrite width and height if we can get it from style
        var styleWidth = getStyleSize( style.width );
        if ( styleWidth !== false ) {
            size.width = styleWidth +
                // add padding and border unless it's already including it
                ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
        }

        var styleHeight = getStyleSize( style.height );
        if ( styleHeight !== false ) {
            size.height = styleHeight +
                // add padding and border unless it's already including it
                ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
        }

        size.innerWidth = size.width - ( paddingWidth + borderWidth );
        size.innerHeight = size.height - ( paddingHeight + borderHeight );

        size.outerWidth = size.width + marginWidth;
        size.outerHeight = size.height + marginHeight;

        return size;
    }

    return getSize;

});

/**
 * matchesSelector v2.0.1
 * matchesSelector( element, '.selector' )
 * MIT license
 */

/*jshint browser: true, strict: true, undef: true, unused: true */

( function( window, factory ) {
    /*global define: false, module: false */
    'use strict';
    // universal module definition
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'desandro-matches-selector/matches-selector',factory );
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory();
    } else {
        // browser global
        window.matchesSelector = factory();
    }

}( window, function factory() {
    'use strict';

    var matchesMethod = ( function() {
        var ElemProto = Element.prototype;
        // check for the standard method name first
        if ( ElemProto.matches ) {
            return 'matches';
        }
        // check un-prefixed
        if ( ElemProto.matchesSelector ) {
            return 'matchesSelector';
        }
        // check vendor prefixes
        var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];

        for ( var i=0; i < prefixes.length; i++ ) {
            var prefix = prefixes[i];
            var method = prefix + 'MatchesSelector';
            if ( ElemProto[ method ] ) {
                return method;
            }
        }
    })();

    return function matchesSelector( elem, selector ) {
        return elem[ matchesMethod ]( selector );
    };

}));

/**
 * Fizzy UI utils v2.0.2
 * MIT license
 */

/*jshint browser: true, undef: true, unused: true, strict: true */

( function( window, factory ) {
    // universal module definition
    /*jshint strict: false */ /*globals define, module, require */

    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'fizzy-ui-utils/utils',[
            'desandro-matches-selector/matches-selector'
        ], function( matchesSelector ) {
            return factory( window, matchesSelector );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('desandro-matches-selector')
        );
    } else {
        // browser global
        window.fizzyUIUtils = factory(
            window,
            window.matchesSelector
        );
    }

}( window, function factory( window, matchesSelector ) {



    var utils = {};

// ----- extend ----- //

// extends objects
    utils.extend = function( a, b ) {
        for ( var prop in b ) {
            a[ prop ] = b[ prop ];
        }
        return a;
    };

// ----- modulo ----- //

    utils.modulo = function( num, div ) {
        return ( ( num % div ) + div ) % div;
    };

// ----- makeArray ----- //

// turn element or nodeList into an array
    utils.makeArray = function( obj ) {
        var ary = [];
        if ( Array.isArray( obj ) ) {
            // use object if already an array
            ary = obj;
        } else if ( obj && typeof obj.length == 'number' ) {
            // convert nodeList to array
            for ( var i=0; i < obj.length; i++ ) {
                ary.push( obj[i] );
            }
        } else {
            // array of single index
            ary.push( obj );
        }
        return ary;
    };

// ----- removeFrom ----- //

    utils.removeFrom = function( ary, obj ) {
        var index = ary.indexOf( obj );
        if ( index != -1 ) {
            ary.splice( index, 1 );
        }
    };

// ----- getParent ----- //

    utils.getParent = function( elem, selector ) {
        while ( elem != document.body ) {
            elem = elem.parentNode;
            if ( matchesSelector( elem, selector ) ) {
                return elem;
            }
        }
    };

// ----- getQueryElement ----- //

// use element as selector string
    utils.getQueryElement = function( elem ) {
        if ( typeof elem == 'string' ) {
            return document.querySelector( elem );
        }
        return elem;
    };

// ----- handleEvent ----- //

// enable .ontype to trigger from .addEventListener( elem, 'type' )
    utils.handleEvent = function( event ) {
        var method = 'on' + event.type;
        if ( this[ method ] ) {
            this[ method ]( event );
        }
    };

// ----- filterFindElements ----- //

    utils.filterFindElements = function( elems, selector ) {
        // make array of elems
        elems = utils.makeArray( elems );
        var ffElems = [];

        elems.forEach( function( elem ) {
            // check that elem is an actual element
            if ( !( elem instanceof HTMLElement ) ) {
                return;
            }
            // add elem if no selector
            if ( !selector ) {
                ffElems.push( elem );
                return;
            }
            // filter & find items if we have a selector
            // filter
            if ( matchesSelector( elem, selector ) ) {
                ffElems.push( elem );
            }
            // find children
            var childElems = elem.querySelectorAll( selector );
            // concat childElems to filterFound array
            for ( var i=0; i < childElems.length; i++ ) {
                ffElems.push( childElems[i] );
            }
        });

        return ffElems;
    };

// ----- debounceMethod ----- //

    utils.debounceMethod = function( _class, methodName, threshold ) {
        // original method
        var method = _class.prototype[ methodName ];
        var timeoutName = methodName + 'Timeout';

        _class.prototype[ methodName ] = function() {
            var timeout = this[ timeoutName ];
            if ( timeout ) {
                clearTimeout( timeout );
            }
            var args = arguments;

            var _this = this;
            this[ timeoutName ] = setTimeout( function() {
                method.apply( _this, args );
                delete _this[ timeoutName ];
            }, threshold || 100 );
        };
    };

// ----- docReady ----- //

    utils.docReady = function( callback ) {
        var readyState = document.readyState;
        if ( readyState == 'complete' || readyState == 'interactive' ) {
            callback();
        } else {
            document.addEventListener( 'DOMContentLoaded', callback );
        }
    };

// ----- htmlInit ----- //

// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
    utils.toDashed = function( str ) {
        return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {
            return $1 + '-' + $2;
        }).toLowerCase();
    };

    var console = window.console;
    /**
     * allow user to initialize classes via [data-namespace] or .js-namespace class
     * htmlInit( Widget, 'widgetName' )
     * options are parsed from data-namespace-options
     */
    utils.htmlInit = function( WidgetClass, namespace ) {
        utils.docReady( function() {
            var dashedNamespace = utils.toDashed( namespace );
            var dataAttr = 'data-' + dashedNamespace;
            var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );
            var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );
            var elems = utils.makeArray( dataAttrElems )
                .concat( utils.makeArray( jsDashElems ) );
            var dataOptionsAttr = dataAttr + '-options';
            var jQuery = window.jQuery;

            elems.forEach( function( elem ) {
                var attr = elem.getAttribute( dataAttr ) ||
                    elem.getAttribute( dataOptionsAttr );
                var options;
                try {
                    options = attr && JSON.parse( attr );
                } catch ( error ) {
                    // log error, do not initialize
                    if ( console ) {
                        console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +
                            ': ' + error );
                    }
                    return;
                }
                // initialize
                var instance = new WidgetClass( elem, options );
                // make available via $().data('layoutname')
                if ( jQuery ) {
                    jQuery.data( elem, namespace, instance );
                }
            });

        });
    };

// -----  ----- //

    return utils;

}));

// Flickity.Cell
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/cell',[
            'get-size/get-size'
        ], function( getSize ) {
            return factory( window, getSize );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('get-size')
        );
    } else {
        // browser global
        window.Flickity = window.Flickity || {};
        window.Flickity.Cell = factory(
            window,
            window.getSize
        );
    }

}( window, function factory( window, getSize ) {



    function Cell( elem, parent ) {
        this.element = elem;
        this.parent = parent;

        this.create();
    }

    var proto = Cell.prototype;

    proto.create = function() {
        this.element.style.position = 'absolute';
        this.x = 0;
        this.shift = 0;
    };

    proto.destroy = function() {
        // reset style
        this.element.style.position = '';
        var side = this.parent.originSide;
        this.element.style[ side ] = '';
    };

    proto.getSize = function() {
        this.size = getSize( this.element );
    };

    proto.setPosition = function( x ) {
        this.x = x;
        this.updateTarget();
        this.renderPosition( x );
    };

// setDefaultTarget v1 method, backwards compatibility, remove in v3
    proto.updateTarget = proto.setDefaultTarget = function() {
        var marginProperty = this.parent.originSide == 'left' ? 'marginLeft' : 'marginRight';
        this.target = this.x + this.size[ marginProperty ] +
            this.size.width * this.parent.cellAlign;
    };

    proto.renderPosition = function( x ) {
        // render position of cell with in slider
        var side = this.parent.originSide;
        this.element.style[ side ] = this.parent.getPositionValue( x );
    };

    /**
     * @param {Integer} factor - 0, 1, or -1
     **/
    proto.wrapShift = function( shift ) {
        this.shift = shift;
        this.renderPosition( this.x + this.parent.slideableWidth * shift );
    };

    proto.remove = function() {
        this.element.parentNode.removeChild( this.element );
    };

    return Cell;

}));

// slide
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/slide',factory );
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory();
    } else {
        // browser global
        window.Flickity = window.Flickity || {};
        window.Flickity.Slide = factory();
    }

}( window, function factory() {
    'use strict';

    function Slide( parent ) {
        this.parent = parent;
        this.isOriginLeft = parent.originSide == 'left';
        this.cells = [];
        this.outerWidth = 0;
        this.height = 0;
    }

    var proto = Slide.prototype;

    proto.addCell = function( cell ) {
        this.cells.push( cell );
        this.outerWidth += cell.size.outerWidth;
        this.height = Math.max( cell.size.outerHeight, this.height );
        // first cell stuff
        if ( this.cells.length == 1 ) {
            this.x = cell.x; // x comes from first cell
            var beginMargin = this.isOriginLeft ? 'marginLeft' : 'marginRight';
            this.firstMargin = cell.size[ beginMargin ];
        }
    };

    proto.updateTarget = function() {
        var endMargin = this.isOriginLeft ? 'marginRight' : 'marginLeft';
        var lastCell = this.getLastCell();
        var lastMargin = lastCell ? lastCell.size[ endMargin ] : 0;
        var slideWidth = this.outerWidth - ( this.firstMargin + lastMargin );
        this.target = this.x + this.firstMargin + slideWidth * this.parent.cellAlign;
    };

    proto.getLastCell = function() {
        return this.cells[ this.cells.length - 1 ];
    };

    proto.select = function() {
        this.changeSelectedClass('add');
    };

    proto.unselect = function() {
        this.changeSelectedClass('remove');
    };

    proto.changeSelectedClass = function( method ) {
        this.cells.forEach( function( cell ) {
            cell.element.classList[ method ]('is-selected');
        });
    };

    proto.getCellElements = function() {
        return this.cells.map( function( cell ) {
            return cell.element;
        });
    };

    return Slide;

}));

// animate
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/animate',[
            'fizzy-ui-utils/utils'
        ], function( utils ) {
            return factory( window, utils );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('fizzy-ui-utils')
        );
    } else {
        // browser global
        window.Flickity = window.Flickity || {};
        window.Flickity.animatePrototype = factory(
            window,
            window.fizzyUIUtils
        );
    }

}( window, function factory( window, utils ) {



// -------------------------- requestAnimationFrame -------------------------- //

// get rAF, prefixed, if present
    var requestAnimationFrame = window.requestAnimationFrame ||
        window.webkitRequestAnimationFrame;

// fallback to setTimeout
    var lastTime = 0;
    if ( !requestAnimationFrame )  {
        requestAnimationFrame = function( callback ) {
            var currTime = new Date().getTime();
            var timeToCall = Math.max( 0, 16 - ( currTime - lastTime ) );
            var id = setTimeout( callback, timeToCall );
            lastTime = currTime + timeToCall;
            return id;
        };
    }

// -------------------------- animate -------------------------- //

    var proto = {};

    proto.startAnimation = function() {
        if ( this.isAnimating ) {
            return;
        }

        this.isAnimating = true;
        this.restingFrames = 0;
        this.animate();
    };

    proto.animate = function() {
        this.applyDragForce();
        this.applySelectedAttraction();

        var previousX = this.x;

        this.integratePhysics();
        this.positionSlider();
        this.settle( previousX );
        // animate next frame
        if ( this.isAnimating ) {
            var _this = this;
            requestAnimationFrame( function animateFrame() {
                _this.animate();
            });
        }
    };


    var transformProperty = ( function () {
        var style = document.documentElement.style;
        if ( typeof style.transform == 'string' ) {
            return 'transform';
        }
        return 'WebkitTransform';
    })();

    proto.positionSlider = function() {
        var x = this.x;
        // wrap position around
        if ( this.options.wrapAround && this.cells.length > 1 ) {
            x = utils.modulo( x, this.slideableWidth );
            x = x - this.slideableWidth;
            this.shiftWrapCells( x );
        }

        x = x + this.cursorPosition;
        // reverse if right-to-left and using transform
        x = this.options.rightToLeft && transformProperty ? -x : x;
        var value = this.getPositionValue( x );
        // use 3D tranforms for hardware acceleration on iOS
        // but use 2D when settled, for better font-rendering
        this.slider.style[ transformProperty ] = this.isAnimating ?
            'translate3d(' + value + ',0,0)' : 'translateX(' + value + ')';

        // scroll event
        var firstSlide = this.slides[0];
        if ( firstSlide ) {
            var positionX = -this.x - firstSlide.target;
            var progress = positionX / this.slidesWidth;
            this.dispatchEvent( 'scroll', null, [ progress, positionX ] );
        }
    };

    proto.positionSliderAtSelected = function() {
        if ( !this.cells.length ) {
            return;
        }
        this.x = -this.selectedSlide.target;
        this.positionSlider();
    };

    proto.getPositionValue = function( position ) {
        if ( this.options.percentPosition ) {
            // percent position, round to 2 digits, like 12.34%
            return ( Math.round( ( position / this.size.innerWidth ) * 10000 ) * 0.01 )+ '%';
        } else {
            // pixel positioning
            return Math.round( position ) + 'px';
        }
    };

    proto.settle = function( previousX ) {
        // keep track of frames where x hasn't moved
        if ( !this.isPointerDown && Math.round( this.x * 100 ) == Math.round( previousX * 100 ) ) {
            this.restingFrames++;
        }
        // stop animating if resting for 3 or more frames
        if ( this.restingFrames > 2 ) {
            this.isAnimating = false;
            delete this.isFreeScrolling;
            // render position with translateX when settled
            this.positionSlider();
            this.dispatchEvent('settle');
        }
    };

    proto.shiftWrapCells = function( x ) {
        // shift before cells
        var beforeGap = this.cursorPosition + x;
        this._shiftCells( this.beforeShiftCells, beforeGap, -1 );
        // shift after cells
        var afterGap = this.size.innerWidth - ( x + this.slideableWidth + this.cursorPosition );
        this._shiftCells( this.afterShiftCells, afterGap, 1 );
    };

    proto._shiftCells = function( cells, gap, shift ) {
        for ( var i=0; i < cells.length; i++ ) {
            var cell = cells[i];
            var cellShift = gap > 0 ? shift : 0;
            cell.wrapShift( cellShift );
            gap -= cell.size.outerWidth;
        }
    };

    proto._unshiftCells = function( cells ) {
        if ( !cells || !cells.length ) {
            return;
        }
        for ( var i=0; i < cells.length; i++ ) {
            cells[i].wrapShift( 0 );
        }
    };

// -------------------------- physics -------------------------- //

    proto.integratePhysics = function() {
        this.x += this.velocity;
        this.velocity *= this.getFrictionFactor();
    };

    proto.applyForce = function( force ) {
        this.velocity += force;
    };

    proto.getFrictionFactor = function() {
        return 1 - this.options[ this.isFreeScrolling ? 'freeScrollFriction' : 'friction' ];
    };

    proto.getRestingPosition = function() {
        // my thanks to Steven Wittens, who simplified this math greatly
        return this.x + this.velocity / ( 1 - this.getFrictionFactor() );
    };

    proto.applyDragForce = function() {
        if ( !this.isPointerDown ) {
            return;
        }
        // change the position to drag position by applying force
        var dragVelocity = this.dragX - this.x;
        var dragForce = dragVelocity - this.velocity;
        this.applyForce( dragForce );
    };

    proto.applySelectedAttraction = function() {
        // do not attract if pointer down or no cells
        if ( this.isPointerDown || this.isFreeScrolling || !this.cells.length ) {
            return;
        }
        var distance = this.selectedSlide.target * -1 - this.x;
        var force = distance * this.options.selectedAttraction;
        this.applyForce( force );
    };

    return proto;

}));

// Flickity main
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/flickity',[
            'ev-emitter/ev-emitter',
            'get-size/get-size',
            'fizzy-ui-utils/utils',
            './cell',
            './slide',
            './animate'
        ], function( EvEmitter, getSize, utils, Cell, Slide, animatePrototype ) {
            return factory( window, EvEmitter, getSize, utils, Cell, Slide, animatePrototype );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('ev-emitter'),
            require('get-size'),
            require('fizzy-ui-utils'),
            require('./cell'),
            require('./slide'),
            require('./animate')
        );
    } else {
        // browser global
        var _Flickity = window.Flickity;

        window.Flickity = factory(
            window,
            window.EvEmitter,
            window.getSize,
            window.fizzyUIUtils,
            _Flickity.Cell,
            _Flickity.Slide,
            _Flickity.animatePrototype
        );
    }

}( window, function factory( window, EvEmitter, getSize,
                             utils, Cell, Slide, animatePrototype ) {



// vars
    var jQuery = window.jQuery;
    var getComputedStyle = window.getComputedStyle;
    var console = window.console;

    function moveElements( elems, toElem ) {
        elems = utils.makeArray( elems );
        while ( elems.length ) {
            toElem.appendChild( elems.shift() );
        }
    }

// -------------------------- Flickity -------------------------- //

// globally unique identifiers
    var GUID = 0;
// internal store of all Flickity intances
    var instances = {};

    function Flickity( element, options ) {
        var queryElement = utils.getQueryElement( element );
        if ( !queryElement ) {
            if ( console ) {
                console.error( 'Bad element for Flickity: ' + ( queryElement || element ) );
            }
            return;
        }
        this.element = queryElement;
        // add jQuery
        if ( jQuery ) {
            this.$element = jQuery( this.element );
        }
        // options
        this.options = utils.extend( {}, this.constructor.defaults );
        this.option( options );

        // kick things off
        this._create();
    }

    Flickity.defaults = {
        accessibility: true,
        // adaptiveHeight: false,
        cellAlign: 'left',
        // cellSelector: undefined,
        // contain: false,
        freeScrollFriction: 0.075, // friction when free-scrolling
        friction: 0.28, // friction when selecting
        namespaceJQueryEvents: true,
        // initialIndex: 0,
        pageDots: false,
        prevNextButtons: false,
        percentPosition: true,
        resize: true,
        selectedAttraction: 0.025,
        setGallerySize: true
        // watchCSS: false,
        // wrapAround: false
    };

// hash of methods triggered on _create()
    Flickity.createMethods = [];

    var proto = Flickity.prototype;
// inherit EventEmitter
    utils.extend( proto, EvEmitter.prototype );

    proto._create = function() {
        // add id for Flickity.data
        var id = this.guid = ++GUID;
        this.element.flickityGUID = id; // expando
        instances[ id ] = this; // associate via id
        // initial properties
        this.selectedIndex = 0;
        // how many frames slider has been in same position
        this.restingFrames = 0;
        // initial physics properties
        this.x = 0;
        this.velocity = 0;
        this.originSide = this.options.rightToLeft ? 'right' : 'left';
        // create viewport & slider
        this.viewport = document.createElement('div');
        this.viewport.className = 'flickity-viewport';
        this._createSlider();

        if ( this.options.resize || this.options.watchCSS ) {
            window.addEventListener( 'resize', this );
        }

        Flickity.createMethods.forEach( function( method ) {
            this[ method ]();
        }, this );

        if ( this.options.watchCSS ) {
            this.watchCSS();
        } else {
            this.activate();
        }

    };

    /**
     * set options
     * @param {Object} opts
     */
    proto.option = function( opts ) {
        utils.extend( this.options, opts );
    };

    proto.activate = function() {
        if ( this.isActive ) {
            return;
        }
        this.isActive = true;
        this.element.classList.add('flickity-enabled');
        if ( this.options.rightToLeft ) {
            this.element.classList.add('flickity-rtl');
        }

        this.getSize();
        // move initial cell elements so they can be loaded as cells
        var cellElems = this._filterFindCellElements( this.element.children );
        moveElements( cellElems, this.slider );
        this.viewport.appendChild( this.slider );
        this.element.appendChild( this.viewport );
        // get cells from children
        this.reloadCells();

        if ( this.options.accessibility ) {
            // allow element to focusable
            this.element.tabIndex = 0;
            // listen for key presses
            this.element.addEventListener( 'keydown', this );
        }

        this.emitEvent('activate');

        var index;
        var initialIndex = this.options.initialIndex;
        if ( this.isInitActivated ) {
            index = this.selectedIndex;
        } else if ( initialIndex !== undefined ) {
            index = this.cells[ initialIndex ] ? initialIndex : 0;
        } else {
            index = 0;
        }
        // select instantly
        this.select( index, false, true );
        // flag for initial activation, for using initialIndex
        this.isInitActivated = true;
    };

// slider positions the cells
    proto._createSlider = function() {
        // slider element does all the positioning
        var slider = document.createElement('div');
        slider.className = 'flickity-slider';
        slider.style[ this.originSide ] = 0;
        this.slider = slider;
    };

    proto._filterFindCellElements = function( elems ) {
        return utils.filterFindElements( elems, this.options.cellSelector );
    };

// goes through all children
    proto.reloadCells = function() {
        // collection of item elements
        this.cells = this._makeCells( this.slider.children );
        this.positionCells();
        this._getWrapShiftCells();
        this.setGallerySize();
    };

    /**
     * turn elements into Flickity.Cells
     * @param {Array or NodeList or HTMLElement} elems
     * @returns {Array} items - collection of new Flickity Cells
     */
    proto._makeCells = function( elems ) {
        var cellElems = this._filterFindCellElements( elems );

        // create new Flickity for collection
        var cells = cellElems.map( function( cellElem ) {
            return new Cell( cellElem, this );
        }, this );

        return cells;
    };

    proto.getLastCell = function() {
        return this.cells[ this.cells.length - 1 ];
    };

    proto.getLastSlide = function() {
        return this.slides[ this.slides.length - 1 ];
    };

// positions all cells
    proto.positionCells = function() {
        // size all cells
        this._sizeCells( this.cells );
        // position all cells
        this._positionCells( 0 );
    };

    /**
     * position certain cells
     * @param {Integer} index - which cell to start with
     */
    proto._positionCells = function( index ) {
        index = index || 0;
        // also measure maxCellHeight
        // start 0 if positioning all cells
        this.maxCellHeight = index ? this.maxCellHeight || 0 : 0;
        var cellX = 0;
        // get cellX
        if ( index > 0 ) {
            var startCell = this.cells[ index - 1 ];
            cellX = startCell.x + startCell.size.outerWidth;
        }
        var len = this.cells.length;
        for ( var i=index; i < len; i++ ) {
            var cell = this.cells[i];
            cell.setPosition( cellX );
            cellX += cell.size.outerWidth;
            this.maxCellHeight = Math.max( cell.size.outerHeight, this.maxCellHeight );
        }
        // keep track of cellX for wrap-around
        this.slideableWidth = cellX;
        // slides
        this.updateSlides();
        // contain slides target
        this._containSlides();
        // update slidesWidth
        this.slidesWidth = len ? this.getLastSlide().target - this.slides[0].target : 0;
    };

    /**
     * cell.getSize() on multiple cells
     * @param {Array} cells
     */
    proto._sizeCells = function( cells ) {
        cells.forEach( function( cell ) {
            cell.getSize();
        });
    };

// --------------------------  -------------------------- //

    proto.updateSlides = function() {
        this.slides = [];
        if ( !this.cells.length ) {
            return;
        }

        var slide = new Slide( this );
        this.slides.push( slide );
        var isOriginLeft = this.originSide == 'left';
        var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';

        var canCellFit = this._getCanCellFit();

        this.cells.forEach( function( cell, i ) {
            // just add cell if first cell in slide
            if ( !slide.cells.length ) {
                slide.addCell( cell );
                return;
            }

            var slideWidth = ( slide.outerWidth - slide.firstMargin ) +
                ( cell.size.outerWidth - cell.size[ nextMargin ] );

            if ( canCellFit.call( this, i, slideWidth ) ) {
                slide.addCell( cell );
            } else {
                // doesn't fit, new slide
                slide.updateTarget();

                slide = new Slide( this );
                this.slides.push( slide );
                slide.addCell( cell );
            }
        }, this );
        // last slide
        slide.updateTarget();
        // update .selectedSlide
        this.updateSelectedSlide();
    };

    proto._getCanCellFit = function() {
        var groupCells = this.options.groupCells;
        if ( !groupCells ) {
            return function() {
                return false;
            };
        } else if ( typeof groupCells == 'number' ) {
            // group by number. 3 -> [0,1,2], [3,4,5], ...
            var number = parseInt( groupCells, 10 );
            return function( i ) {
                return ( i % number ) !== 0;
            };
        }
        // default, group by width of slide
        // parse '75%
        var percentMatch = typeof groupCells == 'string' &&
            groupCells.match(/^(\d+)%$/);
        var percent = percentMatch ? parseInt( percentMatch[1], 10 ) / 100 : 1;
        return function( i, slideWidth ) {
            return slideWidth <= ( this.size.innerWidth + 1 ) * percent;
        };
    };

// alias _init for jQuery plugin .flickity()
    proto._init =
        proto.reposition = function() {
            this.positionCells();
            this.positionSliderAtSelected();
        };

    proto.getSize = function() {
        this.size = getSize( this.element );
        this.setCellAlign();
        this.cursorPosition = this.size.innerWidth * this.cellAlign;
    };

    var cellAlignShorthands = {
        // cell align, then based on origin side
        center: {
            left: 0.5,
            right: 0.5
        },
        left: {
            left: 0,
            right: 1
        },
        right: {
            right: 0,
            left: 1
        }
    };

    proto.setCellAlign = function() {
        var shorthand = cellAlignShorthands[ this.options.cellAlign ];
        this.cellAlign = shorthand ? shorthand[ this.originSide ] : this.options.cellAlign;
    };

    proto.setGallerySize = function() {
        if ( this.options.setGallerySize ) {
            var height = this.options.adaptiveHeight && this.selectedSlide ?
                this.selectedSlide.height : this.maxCellHeight;
            this.viewport.style.height = height + 'px';
        }
    };

    proto._getWrapShiftCells = function() {
        // only for wrap-around
        if ( !this.options.wrapAround ) {
            return;
        }
        // unshift previous cells
        this._unshiftCells( this.beforeShiftCells );
        this._unshiftCells( this.afterShiftCells );
        // get before cells
        // initial gap
        var gapX = this.cursorPosition;
        var cellIndex = this.cells.length - 1;
        this.beforeShiftCells = this._getGapCells( gapX, cellIndex, -1 );
        // get after cells
        // ending gap between last cell and end of gallery viewport
        gapX = this.size.innerWidth - this.cursorPosition;
        // start cloning at first cell, working forwards
        this.afterShiftCells = this._getGapCells( gapX, 0, 1 );
    };

    proto._getGapCells = function( gapX, cellIndex, increment ) {
        // keep adding cells until the cover the initial gap
        var cells = [];
        while ( gapX > 0 ) {
            var cell = this.cells[ cellIndex ];
            if ( !cell ) {
                break;
            }
            cells.push( cell );
            cellIndex += increment;
            gapX -= cell.size.outerWidth;
        }
        return cells;
    };

// ----- contain ----- //

// contain cell targets so no excess sliding
    proto._containSlides = function() {
        if ( !this.options.contain || this.options.wrapAround || !this.cells.length ) {
            return;
        }
        var isRightToLeft = this.options.rightToLeft;
        var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';
        var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';
        var contentWidth = this.slideableWidth - this.getLastCell().size[ endMargin ];
        // content is less than gallery size
        var isContentSmaller = contentWidth < this.size.innerWidth;
        // bounds
        var beginBound = this.cursorPosition + this.cells[0].size[ beginMargin ];
        var endBound = contentWidth - this.size.innerWidth * ( 1 - this.cellAlign );
        // contain each cell target
        this.slides.forEach( function( slide ) {
            if ( isContentSmaller ) {
                // all cells fit inside gallery
                slide.target = contentWidth * this.cellAlign;
            } else {
                // contain to bounds
                slide.target = Math.max( slide.target, beginBound );
                slide.target = Math.min( slide.target, endBound );
            }
        }, this );
    };

// -----  ----- //

    /**
     * emits events via eventEmitter and jQuery events
     * @param {String} type - name of event
     * @param {Event} event - original event
     * @param {Array} args - extra arguments
     */
    proto.dispatchEvent = function( type, event, args ) {
        var emitArgs = event ? [ event ].concat( args ) : args;
        this.emitEvent( type, emitArgs );

        if ( jQuery && this.$element ) {
            // default trigger with type if no event
            type += this.options.namespaceJQueryEvents ? '.flickity' : '';
            var $event = type;
            if ( event ) {
                // create jQuery event
                var jQEvent = jQuery.Event( event );
                jQEvent.type = type;
                $event = jQEvent;
            }
            this.$element.trigger( $event, args );
        }
    };

// -------------------------- select -------------------------- //

    /**
     * @param {Integer} index - index of the slide
     * @param {Boolean} isWrap - will wrap-around to last/first if at the end
     * @param {Boolean} isInstant - will immediately set position at selected cell
     */
    proto.select = function( index, isWrap, isInstant ) {
        if ( !this.isActive ) {
            return;
        }
        index = parseInt( index, 10 );
        this._wrapSelect( index );

        if ( this.options.wrapAround || isWrap ) {
            index = utils.modulo( index, this.slides.length );
        }
        // bail if invalid index
        if ( !this.slides[ index ] ) {
            return;
        }
        this.selectedIndex = index;
        this.updateSelectedSlide();
        if ( isInstant ) {
            this.positionSliderAtSelected();
        } else {
            this.startAnimation();
        }
        if ( this.options.adaptiveHeight ) {
            this.setGallerySize();
        }

        this.dispatchEvent('select');
        // old v1 event name, remove in v3
        this.dispatchEvent('cellSelect');
    };

// wraps position for wrapAround, to move to closest slide. #113
    proto._wrapSelect = function( index ) {
        var len = this.slides.length;
        var isWrapping = this.options.wrapAround && len > 1;
        if ( !isWrapping ) {
            return index;
        }
        var wrapIndex = utils.modulo( index, len );
        // go to shortest
        var delta = Math.abs( wrapIndex - this.selectedIndex );
        var backWrapDelta = Math.abs( ( wrapIndex + len ) - this.selectedIndex );
        var forewardWrapDelta = Math.abs( ( wrapIndex - len ) - this.selectedIndex );
        if ( !this.isDragSelect && backWrapDelta < delta ) {
            index += len;
        } else if ( !this.isDragSelect && forewardWrapDelta < delta ) {
            index -= len;
        }
        // wrap position so slider is within normal area
        if ( index < 0 ) {
            this.x -= this.slideableWidth;
        } else if ( index >= len ) {
            this.x += this.slideableWidth;
        }
    };

    proto.previous = function( isWrap ) {
        this.select( this.selectedIndex - 1, isWrap );
    };

    proto.next = function( isWrap ) {
        this.select( this.selectedIndex + 1, isWrap );
    };

    proto.updateSelectedSlide = function() {
        var slide = this.slides[ this.selectedIndex ];
        // selectedIndex could be outside of slides, if triggered before resize()
        if ( !slide ) {
            return;
        }
        // unselect previous selected slide
        this.unselectSelectedSlide();
        // update new selected slide
        this.selectedSlide = slide;
        slide.select();
        this.selectedCells = slide.cells;
        this.selectedElements = slide.getCellElements();
        // HACK: selectedCell & selectedElement is first cell in slide, backwards compatibility
        // Remove in v3?
        this.selectedCell = slide.cells[0];
        this.selectedElement = this.selectedElements[0];
    };

    proto.unselectSelectedSlide = function() {
        if ( this.selectedSlide ) {
            this.selectedSlide.unselect();
        }
    };

    /**
     * select slide from number or cell element
     * @param {Element or Number} elem
     */
    proto.selectCell = function( value, isWrap, isInstant ) {
        // get cell
        var cell;
        if ( typeof value == 'number' ) {
            cell = this.cells[ value ];
        } else {
            // use string as selector
            if ( typeof value == 'string' ) {
                value = this.element.querySelector( value );
            }
            // get cell from element
            cell = this.getCell( value );
        }
        // select slide that has cell
        for ( var i=0; cell && i < this.slides.length; i++ ) {
            var slide = this.slides[i];
            var index = slide.cells.indexOf( cell );
            if ( index != -1 ) {
                this.select( i, isWrap, isInstant );
                return;
            }
        }
    };

// -------------------------- get cells -------------------------- //

    /**
     * get Flickity.Cell, given an Element
     * @param {Element} elem
     * @returns {Flickity.Cell} item
     */
    proto.getCell = function( elem ) {
        // loop through cells to get the one that matches
        for ( var i=0; i < this.cells.length; i++ ) {
            var cell = this.cells[i];
            if ( cell.element == elem ) {
                return cell;
            }
        }
    };

    /**
     * get collection of Flickity.Cells, given Elements
     * @param {Element, Array, NodeList} elems
     * @returns {Array} cells - Flickity.Cells
     */
    proto.getCells = function( elems ) {
        elems = utils.makeArray( elems );
        var cells = [];
        elems.forEach( function( elem ) {
            var cell = this.getCell( elem );
            if ( cell ) {
                cells.push( cell );
            }
        }, this );
        return cells;
    };

    /**
     * get cell elements
     * @returns {Array} cellElems
     */
    proto.getCellElements = function() {
        return this.cells.map( function( cell ) {
            return cell.element;
        });
    };

    /**
     * get parent cell from an element
     * @param {Element} elem
     * @returns {Flickit.Cell} cell
     */
    proto.getParentCell = function( elem ) {
        // first check if elem is cell
        var cell = this.getCell( elem );
        if ( cell ) {
            return cell;
        }
        // try to get parent cell elem
        elem = utils.getParent( elem, '.flickity-slider > *' );
        return this.getCell( elem );
    };

    /**
     * get cells adjacent to a slide
     * @param {Integer} adjCount - number of adjacent slides
     * @param {Integer} index - index of slide to start
     * @returns {Array} cells - array of Flickity.Cells
     */
    proto.getAdjacentCellElements = function( adjCount, index ) {
        if ( !adjCount ) {
            return this.selectedSlide.getCellElements();
        }
        index = index === undefined ? this.selectedIndex : index;

        var len = this.slides.length;
        if ( 1 + ( adjCount * 2 ) >= len ) {
            return this.getCellElements();
        }

        var cellElems = [];
        for ( var i = index - adjCount; i <= index + adjCount ; i++ ) {
            var slideIndex = this.options.wrapAround ? utils.modulo( i, len ) : i;
            var slide = this.slides[ slideIndex ];
            if ( slide ) {
                cellElems = cellElems.concat( slide.getCellElements() );
            }
        }
        return cellElems;
    };

// -------------------------- events -------------------------- //

    proto.uiChange = function() {
        this.emitEvent('uiChange');
    };

    proto.childUIPointerDown = function( event ) {
        this.emitEvent( 'childUIPointerDown', [ event ] );
    };

// ----- resize ----- //

    proto.onresize = function() {
        this.watchCSS();
        this.resize();
    };

    utils.debounceMethod( Flickity, 'onresize', 150 );

    proto.resize = function() {
        if ( !this.isActive ) {
            return;
        }
        this.getSize();
        // wrap values
        if ( this.options.wrapAround ) {
            this.x = utils.modulo( this.x, this.slideableWidth );
        }
        this.positionCells();
        this._getWrapShiftCells();
        this.setGallerySize();
        this.emitEvent('resize');
        // update selected index for group slides, instant
        // TODO: position can be lost between groups of various numbers
        var selectedElement = this.selectedElements && this.selectedElements[0];
        this.selectCell( selectedElement, false, true );
    };

// watches the :after property, activates/deactivates
    proto.watchCSS = function() {
        var watchOption = this.options.watchCSS;
        if ( !watchOption ) {
            return;
        }

        var afterContent = getComputedStyle( this.element, ':after' ).content;
        // activate if :after { content: 'flickity' }
        if ( afterContent.indexOf('flickity') != -1 ) {
            this.activate();
        } else {
            this.deactivate();
        }
    };

// ----- keydown ----- //

// go previous/next if left/right keys pressed
    proto.onkeydown = function( event ) {
        // only work if element is in focus
        if ( !this.options.accessibility ||
            ( document.activeElement && document.activeElement != this.element ) ) {
            return;
        }

        if ( event.keyCode == 37 ) {
            // go left
            var leftMethod = this.options.rightToLeft ? 'next' : 'previous';
            this.uiChange();
            this[ leftMethod ]();
        } else if ( event.keyCode == 39 ) {
            // go right
            var rightMethod = this.options.rightToLeft ? 'previous' : 'next';
            this.uiChange();
            this[ rightMethod ]();
        }
    };

// -------------------------- destroy -------------------------- //

// deactivate all Flickity functionality, but keep stuff available
    proto.deactivate = function() {
        if ( !this.isActive ) {
            return;
        }
        this.element.classList.remove('flickity-enabled');
        this.element.classList.remove('flickity-rtl');
        // destroy cells
        this.cells.forEach( function( cell ) {
            cell.destroy();
        });
        this.unselectSelectedSlide();
        this.element.removeChild( this.viewport );
        // move child elements back into element
        moveElements( this.slider.children, this.element );
        if ( this.options.accessibility ) {
            this.element.removeAttribute('tabIndex');
            this.element.removeEventListener( 'keydown', this );
        }
        // set flags
        this.isActive = false;
        this.emitEvent('deactivate');
    };

    proto.destroy = function() {
        this.deactivate();
        window.removeEventListener( 'resize', this );
        this.emitEvent('destroy');
        if ( jQuery && this.$element ) {
            jQuery.removeData( this.element, 'flickity' );
        }
        delete this.element.flickityGUID;
        delete instances[ this.guid ];
    };

// -------------------------- prototype -------------------------- //

    utils.extend( proto, animatePrototype );

// -------------------------- extras -------------------------- //

    /**
     * get Flickity instance from element
     * @param {Element} elem
     * @returns {Flickity}
     */
    Flickity.data = function( elem ) {
        elem = utils.getQueryElement( elem );
        var id = elem && elem.flickityGUID;
        return id && instances[ id ];
    };

    utils.htmlInit( Flickity, 'flickity' );

    if ( jQuery && jQuery.bridget ) {
        jQuery.bridget( 'flickity', Flickity );
    }

    Flickity.Cell = Cell;

    return Flickity;

}));

/*!
 * Unipointer v2.1.0
 * base class for doing one thing with pointer event
 * MIT license
 */

/*jshint browser: true, undef: true, unused: true, strict: true */

( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */ /*global define, module, require */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'unipointer/unipointer',[
            'ev-emitter/ev-emitter'
        ], function( EvEmitter ) {
            return factory( window, EvEmitter );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('ev-emitter')
        );
    } else {
        // browser global
        window.Unipointer = factory(
            window,
            window.EvEmitter
        );
    }

}( window, function factory( window, EvEmitter ) {



    function noop() {}

    function Unipointer() {}

// inherit EvEmitter
    var proto = Unipointer.prototype = Object.create( EvEmitter.prototype );

    proto.bindStartEvent = function( elem ) {
        this._bindStartEvent( elem, true );
    };

    proto.unbindStartEvent = function( elem ) {
        this._bindStartEvent( elem, false );
    };

    /**
     * works as unbinder, as you can ._bindStart( false ) to unbind
     * @param {Boolean} isBind - will unbind if falsey
     */
    proto._bindStartEvent = function( elem, isBind ) {
        // munge isBind, default to true
        isBind = isBind === undefined ? true : !!isBind;
        var bindMethod = isBind ? 'addEventListener' : 'removeEventListener';

        if ( window.navigator.pointerEnabled ) {
            // W3C Pointer Events, IE11. See https://coderwall.com/p/mfreca
            elem[ bindMethod ]( 'pointerdown', this );
        } else if ( window.navigator.msPointerEnabled ) {
            // IE10 Pointer Events
            elem[ bindMethod ]( 'MSPointerDown', this );
        } else {
            // listen for both, for devices like Chrome Pixel
            elem[ bindMethod ]( 'mousedown', this );
            elem[ bindMethod ]( 'touchstart', this );
        }
    };

// trigger handler methods for events
    proto.handleEvent = function( event ) {
        var method = 'on' + event.type;
        if ( this[ method ] ) {
            this[ method ]( event );
        }
    };

// returns the touch that we're keeping track of
    proto.getTouch = function( touches ) {
        for ( var i=0; i < touches.length; i++ ) {
            var touch = touches[i];
            if ( touch.identifier == this.pointerIdentifier ) {
                return touch;
            }
        }
    };

// ----- start event ----- //

    proto.onmousedown = function( event ) {
        // dismiss clicks from right or middle buttons
        var button = event.button;
        if ( button && ( button !== 0 && button !== 1 ) ) {
            return;
        }
        this._pointerDown( event, event );
    };

    proto.ontouchstart = function( event ) {
        this._pointerDown( event, event.changedTouches[0] );
    };

    proto.onMSPointerDown =
        proto.onpointerdown = function( event ) {
            this._pointerDown( event, event );
        };

    /**
     * pointer start
     * @param {Event} event
     * @param {Event or Touch} pointer
     */
    proto._pointerDown = function( event, pointer ) {
        // dismiss other pointers
        if ( this.isPointerDown ) {
            return;
        }

        this.isPointerDown = true;
        // save pointer identifier to match up touch events
        this.pointerIdentifier = pointer.pointerId !== undefined ?
            // pointerId for pointer events, touch.indentifier for touch events
            pointer.pointerId : pointer.identifier;

        this.pointerDown( event, pointer );
    };

    proto.pointerDown = function( event, pointer ) {
        this._bindPostStartEvents( event );
        this.emitEvent( 'pointerDown', [ event, pointer ] );
    };

// hash of events to be bound after start event
    var postStartEvents = {
        mousedown: [ 'mousemove', 'mouseup' ],
        touchstart: [ 'touchmove', 'touchend', 'touchcancel' ],
        pointerdown: [ 'pointermove', 'pointerup', 'pointercancel' ],
        MSPointerDown: [ 'MSPointerMove', 'MSPointerUp', 'MSPointerCancel' ]
    };

    proto._bindPostStartEvents = function( event ) {
        if ( !event ) {
            return;
        }
        // get proper events to match start event
        var events = postStartEvents[ event.type ];
        // bind events to node
        events.forEach( function( eventName ) {
            window.addEventListener( eventName, this );
        }, this );
        // save these arguments
        this._boundPointerEvents = events;
    };

    proto._unbindPostStartEvents = function() {
        // check for _boundEvents, in case dragEnd triggered twice (old IE8 bug)
        if ( !this._boundPointerEvents ) {
            return;
        }
        this._boundPointerEvents.forEach( function( eventName ) {
            window.removeEventListener( eventName, this );
        }, this );

        delete this._boundPointerEvents;
    };

// ----- move event ----- //

    proto.onmousemove = function( event ) {
        this._pointerMove( event, event );
    };

    proto.onMSPointerMove =
        proto.onpointermove = function( event ) {
            if ( event.pointerId == this.pointerIdentifier ) {
                this._pointerMove( event, event );
            }
        };

    proto.ontouchmove = function( event ) {
        var touch = this.getTouch( event.changedTouches );
        if ( touch ) {
            this._pointerMove( event, touch );
        }
    };

    /**
     * pointer move
     * @param {Event} event
     * @param {Event or Touch} pointer
     * @private
     */
    proto._pointerMove = function( event, pointer ) {
        this.pointerMove( event, pointer );
    };

// public
    proto.pointerMove = function( event, pointer ) {
        this.emitEvent( 'pointerMove', [ event, pointer ] );
    };

// ----- end event ----- //


    proto.onmouseup = function( event ) {
        this._pointerUp( event, event );
    };

    proto.onMSPointerUp =
        proto.onpointerup = function( event ) {
            if ( event.pointerId == this.pointerIdentifier ) {
                this._pointerUp( event, event );
            }
        };

    proto.ontouchend = function( event ) {
        var touch = this.getTouch( event.changedTouches );
        if ( touch ) {
            this._pointerUp( event, touch );
        }
    };

    /**
     * pointer up
     * @param {Event} event
     * @param {Event or Touch} pointer
     * @private
     */
    proto._pointerUp = function( event, pointer ) {
        this._pointerDone();
        this.pointerUp( event, pointer );
    };

// public
    proto.pointerUp = function( event, pointer ) {
        this.emitEvent( 'pointerUp', [ event, pointer ] );
    };

// ----- pointer done ----- //

// triggered on pointer up & pointer cancel
    proto._pointerDone = function() {
        // reset properties
        this.isPointerDown = false;
        delete this.pointerIdentifier;
        // remove events
        this._unbindPostStartEvents();
        this.pointerDone();
    };

    proto.pointerDone = noop;

// ----- pointer cancel ----- //

    proto.onMSPointerCancel =
        proto.onpointercancel = function( event ) {
            if ( event.pointerId == this.pointerIdentifier ) {
                this._pointerCancel( event, event );
            }
        };

    proto.ontouchcancel = function( event ) {
        var touch = this.getTouch( event.changedTouches );
        if ( touch ) {
            this._pointerCancel( event, touch );
        }
    };

    /**
     * pointer cancel
     * @param {Event} event
     * @param {Event or Touch} pointer
     * @private
     */
    proto._pointerCancel = function( event, pointer ) {
        this._pointerDone();
        this.pointerCancel( event, pointer );
    };

// public
    proto.pointerCancel = function( event, pointer ) {
        this.emitEvent( 'pointerCancel', [ event, pointer ] );
    };

// -----  ----- //

// utility function for getting x/y coords from event
    Unipointer.getPointerPoint = function( pointer ) {
        return {
            x: pointer.pageX,
            y: pointer.pageY
        };
    };

// -----  ----- //

    return Unipointer;

}));

/*!
 * Unidragger v2.1.0
 * Draggable base class
 * MIT license
 */

/*jshint browser: true, unused: true, undef: true, strict: true */

( function( window, factory ) {
    // universal module definition
    /*jshint strict: false */ /*globals define, module, require */

    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'unidragger/unidragger',[
            'unipointer/unipointer'
        ], function( Unipointer ) {
            return factory( window, Unipointer );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('unipointer')
        );
    } else {
        // browser global
        window.Unidragger = factory(
            window,
            window.Unipointer
        );
    }

}( window, function factory( window, Unipointer ) {



// -----  ----- //

    function noop() {}

// -------------------------- Unidragger -------------------------- //

    function Unidragger() {}

// inherit Unipointer & EvEmitter
    var proto = Unidragger.prototype = Object.create( Unipointer.prototype );

// ----- bind start ----- //

    proto.bindHandles = function() {
        this._bindHandles( true );
    };

    proto.unbindHandles = function() {
        this._bindHandles( false );
    };

    var navigator = window.navigator;
    /**
     * works as unbinder, as you can .bindHandles( false ) to unbind
     * @param {Boolean} isBind - will unbind if falsey
     */
    proto._bindHandles = function( isBind ) {
        // munge isBind, default to true
        isBind = isBind === undefined ? true : !!isBind;
        // extra bind logic
        var binderExtra;
        if ( navigator.pointerEnabled ) {
            binderExtra = function( handle ) {
                // disable scrolling on the element
                handle.style.touchAction = isBind ? 'none' : '';
            };
        } else if ( navigator.msPointerEnabled ) {
            binderExtra = function( handle ) {
                // disable scrolling on the element
                handle.style.msTouchAction = isBind ? 'none' : '';
            };
        } else {
            binderExtra = noop;
        }
        // bind each handle
        var bindMethod = isBind ? 'addEventListener' : 'removeEventListener';
        for ( var i=0; i < this.handles.length; i++ ) {
            var handle = this.handles[i];
            this._bindStartEvent( handle, isBind );
            binderExtra( handle );
            handle[ bindMethod ]( 'click', this );
        }
    };

// ----- start event ----- //

    /**
     * pointer start
     * @param {Event} event
     * @param {Event or Touch} pointer
     */
    proto.pointerDown = function( event, pointer ) {
        // dismiss range sliders
        if ( event.target.nodeName == 'INPUT' && event.target.type == 'range' ) {
            // reset pointerDown logic
            this.isPointerDown = false;
            delete this.pointerIdentifier;
            return;
        }

        this._dragPointerDown( event, pointer );
        // kludge to blur focused inputs in dragger
        var focused = document.activeElement;
        if ( focused && focused.blur ) {
            focused.blur();
        }
        // bind move and end events
        this._bindPostStartEvents( event );
        this.emitEvent( 'pointerDown', [ event, pointer ] );
    };

// base pointer down logic
    proto._dragPointerDown = function( event, pointer ) {
        // track to see when dragging starts
        this.pointerDownPoint = Unipointer.getPointerPoint( pointer );

        var canPreventDefault = this.canPreventDefaultOnPointerDown( event, pointer );
        if ( canPreventDefault ) {
            event.preventDefault();
        }
    };

// overwriteable method so Flickity can prevent for scrolling
    proto.canPreventDefaultOnPointerDown = function( event ) {
        // prevent default, unless touchstart or <select>
        return event.target.nodeName != 'SELECT';
    };

// ----- move event ----- //

    /**
     * drag move
     * @param {Event} event
     * @param {Event or Touch} pointer
     */
    proto.pointerMove = function( event, pointer ) {
        var moveVector = this._dragPointerMove( event, pointer );
        this.emitEvent( 'pointerMove', [ event, pointer, moveVector ] );
        this._dragMove( event, pointer, moveVector );
    };

// base pointer move logic
    proto._dragPointerMove = function( event, pointer ) {
        var movePoint = Unipointer.getPointerPoint( pointer );
        var moveVector = {
            x: movePoint.x - this.pointerDownPoint.x,
            y: movePoint.y - this.pointerDownPoint.y
        };
        // start drag if pointer has moved far enough to start drag
        if ( !this.isDragging && this.hasDragStarted( moveVector ) ) {
            this._dragStart( event, pointer );
        }
        return moveVector;
    };

// condition if pointer has moved far enough to start drag
    proto.hasDragStarted = function( moveVector ) {
        return Math.abs( moveVector.x ) > 3 || Math.abs( moveVector.y ) > 3;
    };


// ----- end event ----- //

    /**
     * pointer up
     * @param {Event} event
     * @param {Event or Touch} pointer
     */
    proto.pointerUp = function( event, pointer ) {
        this.emitEvent( 'pointerUp', [ event, pointer ] );
        this._dragPointerUp( event, pointer );
    };

    proto._dragPointerUp = function( event, pointer ) {
        if ( this.isDragging ) {
            this._dragEnd( event, pointer );
        } else {
            // pointer didn't move enough for drag to start
            this._staticClick( event, pointer );
        }
    };

// -------------------------- drag -------------------------- //

// dragStart
    proto._dragStart = function( event, pointer ) {
        this.isDragging = true;
        this.dragStartPoint = Unipointer.getPointerPoint( pointer );
        // prevent clicks
        this.isPreventingClicks = true;

        this.dragStart( event, pointer );
    };

    proto.dragStart = function( event, pointer ) {
        this.emitEvent( 'dragStart', [ event, pointer ] );
    };

// dragMove
    proto._dragMove = function( event, pointer, moveVector ) {
        // do not drag if not dragging yet
        if ( !this.isDragging ) {
            return;
        }

        this.dragMove( event, pointer, moveVector );
    };

    proto.dragMove = function( event, pointer, moveVector ) {
        event.preventDefault();
        this.emitEvent( 'dragMove', [ event, pointer, moveVector ] );
    };

// dragEnd
    proto._dragEnd = function( event, pointer ) {
        // set flags
        this.isDragging = false;
        // re-enable clicking async
        setTimeout( function() {
            delete this.isPreventingClicks;
        }.bind( this ) );

        this.dragEnd( event, pointer );
    };

    proto.dragEnd = function( event, pointer ) {
        this.emitEvent( 'dragEnd', [ event, pointer ] );
    };

// ----- onclick ----- //

// handle all clicks and prevent clicks when dragging
    proto.onclick = function( event ) {
        if ( this.isPreventingClicks ) {
            event.preventDefault();
        }
    };

// ----- staticClick ----- //

// triggered after pointer down & up with no/tiny movement
    proto._staticClick = function( event, pointer ) {
        // ignore emulated mouse up clicks
        if ( this.isIgnoringMouseUp && event.type == 'mouseup' ) {
            return;
        }

        // allow click in <input>s and <textarea>s
        var nodeName = event.target.nodeName;
        if ( nodeName == 'INPUT' || nodeName == 'TEXTAREA' ) {
            event.target.focus();
        }
        this.staticClick( event, pointer );

        // set flag for emulated clicks 300ms after touchend
        if ( event.type != 'mouseup' ) {
            this.isIgnoringMouseUp = true;
            // reset flag after 300ms
            setTimeout( function() {
                delete this.isIgnoringMouseUp;
            }.bind( this ), 400 );
        }
    };

    proto.staticClick = function( event, pointer ) {
        this.emitEvent( 'staticClick', [ event, pointer ] );
    };

// ----- utils ----- //

    Unidragger.getPointerPoint = Unipointer.getPointerPoint;

// -----  ----- //

    return Unidragger;

}));

// drag
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/drag',[
            './flickity',
            'unidragger/unidragger',
            'fizzy-ui-utils/utils'
        ], function( Flickity, Unidragger, utils ) {
            return factory( window, Flickity, Unidragger, utils );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('./flickity'),
            require('unidragger'),
            require('fizzy-ui-utils')
        );
    } else {
        // browser global
        window.Flickity = factory(
            window,
            window.Flickity,
            window.Unidragger,
            window.fizzyUIUtils
        );
    }

}( window, function factory( window, Flickity, Unidragger, utils ) {



// ----- defaults ----- //

    utils.extend( Flickity.defaults, {
        draggable: true,
        dragThreshold: 8,
    });

// ----- create ----- //

    Flickity.createMethods.push('_createDrag');

// -------------------------- drag prototype -------------------------- //

    var proto = Flickity.prototype;
    utils.extend( proto, Unidragger.prototype );

// --------------------------  -------------------------- //

    proto._createDrag = function() {
        this.on( 'activate', this.bindDrag );
        this.on( 'uiChange', this._uiChangeDrag );
        this.on( 'childUIPointerDown', this._childUIPointerDownDrag );
        this.on( 'deactivate', this.unbindDrag );
    };

    proto.bindDrag = function() {
        if ( !this.options.draggable || this.isDragBound ) {
            return;
        }
        this.element.classList.add('is-draggable');
        this.handles = [ this.viewport ];
        this.bindHandles();
        this.isDragBound = true;
    };

    proto.unbindDrag = function() {
        if ( !this.isDragBound ) {
            return;
        }
        this.element.classList.remove('is-draggable');
        this.unbindHandles();
        delete this.isDragBound;
    };

    proto._uiChangeDrag = function() {
        delete this.isFreeScrolling;
    };

    proto._childUIPointerDownDrag = function( event ) {
        // event.preventDefault();
        this.pointerDownFocus( event );
    };

// -------------------------- pointer events -------------------------- //

// nodes that have text fields
    var cursorNodes = {
        TEXTAREA: true,
        INPUT: true,
    };

// input types that do not have text fields
    var clickTypes = {
        radio: true,
        checkbox: true,
        button: true,
        submit: true,
        image: true,
        file: true,
    };

    proto.pointerDown = function( event, pointer ) {
        // dismiss inputs with text fields. #404
        var isCursorInput = cursorNodes[ event.target.nodeName ] &&
            !clickTypes[ event.target.type ];
        if ( isCursorInput ) {
            // reset pointerDown logic
            this.isPointerDown = false;
            delete this.pointerIdentifier;
            return;
        }

        this._dragPointerDown( event, pointer );

        // kludge to blur focused inputs in dragger
        var focused = document.activeElement;
        if ( focused && focused.blur && focused != this.element &&
            // do not blur body for IE9 & 10, #117
            focused != document.body ) {
            focused.blur();
        }
        this.pointerDownFocus( event );
        // stop if it was moving
        this.dragX = this.x;
        this.viewport.classList.add('is-pointer-down');
        // bind move and end events
        this._bindPostStartEvents( event );
        // track scrolling
        this.pointerDownScroll = getScrollPosition();
        window.addEventListener( 'scroll', this );

        this.dispatchEvent( 'pointerDown', event, [ pointer ] );
    };

    var touchStartEvents = {
        touchstart: true,
        MSPointerDown: true
    };

    var focusNodes = {
        INPUT: true,
        SELECT: true
    };

    proto.pointerDownFocus = function( event ) {
        // focus element, if not touch, and its not an input or select
        if ( !this.options.accessibility || touchStartEvents[ event.type ] ||
            focusNodes[ event.target.nodeName ] ) {
            return;
        }
        var prevScrollY = window.pageYOffset;
        this.element.focus();
        // hack to fix scroll jump after focus, #76
        if ( window.pageYOffset != prevScrollY ) {
            window.scrollTo( window.pageXOffset, prevScrollY );
        }
    };

    proto.canPreventDefaultOnPointerDown = function( event ) {
        // prevent default, unless touchstart or <select>
        var isTouchstart = event.type == 'touchstart';
        var targetNodeName = event.target.nodeName;
        return !isTouchstart && targetNodeName != 'SELECT';
    };

// ----- move ----- //

    proto.hasDragStarted = function( moveVector ) {
        return Math.abs( moveVector.x ) > this.options.dragThreshold;
    };

// ----- up ----- //

    proto.pointerUp = function( event, pointer ) {
        delete this.isTouchScrolling;
        this.viewport.classList.remove('is-pointer-down');
        this.dispatchEvent( 'pointerUp', event, [ pointer ] );
        this._dragPointerUp( event, pointer );
    };

    proto.pointerDone = function() {
        window.removeEventListener( 'scroll', this );
        delete this.pointerDownScroll;
    };

// -------------------------- dragging -------------------------- //

    proto.dragStart = function( event, pointer ) {
        this.dragStartPosition = this.x;
        this.startAnimation();
        this.dispatchEvent( 'dragStart', event, [ pointer ] );
    };

    proto.pointerMove = function( event, pointer ) {
        var moveVector = this._dragPointerMove( event, pointer );
        this.dispatchEvent( 'pointerMove', event, [ pointer, moveVector ] );
        this._dragMove( event, pointer, moveVector );
    };

    proto.dragMove = function( event, pointer, moveVector ) {
        // event.preventDefault();

        this.previousDragX = this.dragX;
        // reverse if right-to-left
        var direction = this.options.rightToLeft ? -1 : 1;
        var dragX = this.dragStartPosition + moveVector.x * direction;

        if ( !this.options.wrapAround && this.slides.length ) {
            // slow drag
            var originBound = Math.max( -this.slides[0].target, this.dragStartPosition );
            dragX = dragX > originBound ? ( dragX + originBound ) * 0.5 : dragX;
            var endBound = Math.min( -this.getLastSlide().target, this.dragStartPosition );
            dragX = dragX < endBound ? ( dragX + endBound ) * 0.5 : dragX;
        }

        this.dragX = dragX;

        this.dragMoveTime = new Date();
        this.dispatchEvent( 'dragMove', event, [ pointer, moveVector ] );
    };

    proto.dragEnd = function( event, pointer ) {
        if ( this.options.freeScroll ) {
            this.isFreeScrolling = true;
        }
        // set selectedIndex based on where flick will end up
        var index = this.dragEndRestingSelect();

        if ( this.options.freeScroll && !this.options.wrapAround ) {
            // if free-scroll & not wrap around
            // do not free-scroll if going outside of bounding slides
            // so bounding slides can attract slider, and keep it in bounds
            var restingX = this.getRestingPosition();
            this.isFreeScrolling = -restingX > this.slides[0].target &&
                -restingX < this.getLastSlide().target;
        } else if ( !this.options.freeScroll && index == this.selectedIndex ) {
            // boost selection if selected index has not changed
            index += this.dragEndBoostSelect();
        }
        delete this.previousDragX;
        // apply selection
        // TODO refactor this, selecting here feels weird
        // HACK, set flag so dragging stays in correct direction
        this.isDragSelect = this.options.wrapAround;
        this.select( index );
        delete this.isDragSelect;
        this.dispatchEvent( 'dragEnd', event, [ pointer ] );
    };

    proto.dragEndRestingSelect = function() {
        var restingX = this.getRestingPosition();
        // how far away from selected slide
        var distance = Math.abs( this.getSlideDistance( -restingX, this.selectedIndex ) );
        // get closet resting going up and going down
        var positiveResting = this._getClosestResting( restingX, distance, 1 );
        var negativeResting = this._getClosestResting( restingX, distance, -1 );
        // use closer resting for wrap-around
        var index = positiveResting.distance < negativeResting.distance ?
            positiveResting.index : negativeResting.index;
        return index;
    };

    /**
     * given resting X and distance to selected cell
     * get the distance and index of the closest cell
     * @param {Number} restingX - estimated post-flick resting position
     * @param {Number} distance - distance to selected cell
     * @param {Integer} increment - +1 or -1, going up or down
     * @returns {Object} - { distance: {Number}, index: {Integer} }
     */
    proto._getClosestResting = function( restingX, distance, increment ) {
        var index = this.selectedIndex;
        var minDistance = Infinity;
        var condition = this.options.contain && !this.options.wrapAround ?
            // if contain, keep going if distance is equal to minDistance
            function( d, md ) { return d <= md; } : function( d, md ) { return d < md; };
        while ( condition( distance, minDistance ) ) {
            // measure distance to next cell
            index += increment;
            minDistance = distance;
            distance = this.getSlideDistance( -restingX, index );
            if ( distance === null ) {
                break;
            }
            distance = Math.abs( distance );
        }
        return {
            distance: minDistance,
            // selected was previous index
            index: index - increment
        };
    };

    /**
     * measure distance between x and a slide target
     * @param {Number} x
     * @param {Integer} index - slide index
     */
    proto.getSlideDistance = function( x, index ) {
        var len = this.slides.length;
        // wrap around if at least 2 slides
        var isWrapAround = this.options.wrapAround && len > 1;
        var slideIndex = isWrapAround ? utils.modulo( index, len ) : index;
        var slide = this.slides[ slideIndex ];
        if ( !slide ) {
            return null;
        }
        // add distance for wrap-around slides
        var wrap = isWrapAround ? this.slideableWidth * Math.floor( index / len ) : 0;
        return x - ( slide.target + wrap );
    };

    proto.dragEndBoostSelect = function() {
        // do not boost if no previousDragX or dragMoveTime
        if ( this.previousDragX === undefined || !this.dragMoveTime ||
            // or if drag was held for 100 ms
            new Date() - this.dragMoveTime > 100 ) {
            return 0;
        }

        var distance = this.getSlideDistance( -this.dragX, this.selectedIndex );
        var delta = this.previousDragX - this.dragX;
        if ( distance > 0 && delta > 0 ) {
            // boost to next if moving towards the right, and positive velocity
            return 1;
        } else if ( distance < 0 && delta < 0 ) {
            // boost to previous if moving towards the left, and negative velocity
            return -1;
        }
        return 0;
    };

// ----- staticClick ----- //

    proto.staticClick = function( event, pointer ) {
        // get clickedCell, if cell was clicked
        var clickedCell = this.getParentCell( event.target );
        var cellElem = clickedCell && clickedCell.element;
        var cellIndex = clickedCell && this.cells.indexOf( clickedCell );
        this.dispatchEvent( 'staticClick', event, [ pointer, cellElem, cellIndex ] );
    };

// ----- scroll ----- //

    proto.onscroll = function() {
        var scroll = getScrollPosition();
        var scrollMoveX = this.pointerDownScroll.x - scroll.x;
        var scrollMoveY = this.pointerDownScroll.y - scroll.y;
        // cancel click/tap if scroll is too much
        if ( Math.abs( scrollMoveX ) > 3 || Math.abs( scrollMoveY ) > 3 ) {
            this._pointerDone();
        }
    };

// ----- utils ----- //

    function getScrollPosition() {
        return {
            x: window.pageXOffset,
            y: window.pageYOffset
        };
    }

// -----  ----- //

    return Flickity;

}));

/*!
 * Tap listener v2.0.0
 * listens to taps
 * MIT license
 */

/*jshint browser: true, unused: true, undef: true, strict: true */

( function( window, factory ) {
    // universal module definition
    /*jshint strict: false*/ /*globals define, module, require */

    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'tap-listener/tap-listener',[
            'unipointer/unipointer'
        ], function( Unipointer ) {
            return factory( window, Unipointer );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('unipointer')
        );
    } else {
        // browser global
        window.TapListener = factory(
            window,
            window.Unipointer
        );
    }

}( window, function factory( window, Unipointer ) {



// --------------------------  TapListener -------------------------- //

    function TapListener( elem ) {
        this.bindTap( elem );
    }

// inherit Unipointer & EventEmitter
    var proto = TapListener.prototype = Object.create( Unipointer.prototype );

    /**
     * bind tap event to element
     * @param {Element} elem
     */
    proto.bindTap = function( elem ) {
        if ( !elem ) {
            return;
        }
        this.unbindTap();
        this.tapElement = elem;
        this._bindStartEvent( elem, true );
    };

    proto.unbindTap = function() {
        if ( !this.tapElement ) {
            return;
        }
        this._bindStartEvent( this.tapElement, true );
        delete this.tapElement;
    };

    /**
     * pointer up
     * @param {Event} event
     * @param {Event or Touch} pointer
     */
    proto.pointerUp = function( event, pointer ) {
        // ignore emulated mouse up clicks
        if ( this.isIgnoringMouseUp && event.type == 'mouseup' ) {
            return;
        }

        var pointerPoint = Unipointer.getPointerPoint( pointer );
        var boundingRect = this.tapElement.getBoundingClientRect();
        var scrollX = window.pageXOffset;
        var scrollY = window.pageYOffset;
        // calculate if pointer is inside tapElement
        var isInside = pointerPoint.x >= boundingRect.left + scrollX &&
            pointerPoint.x <= boundingRect.right + scrollX &&
            pointerPoint.y >= boundingRect.top + scrollY &&
            pointerPoint.y <= boundingRect.bottom + scrollY;
        // trigger callback if pointer is inside element
        if ( isInside ) {
            this.emitEvent( 'tap', [ event, pointer ] );
        }

        // set flag for emulated clicks 300ms after touchend
        if ( event.type != 'mouseup' ) {
            this.isIgnoringMouseUp = true;
            // reset flag after 300ms
            var _this = this;
            setTimeout( function() {
                delete _this.isIgnoringMouseUp;
            }, 400 );
        }
    };

    proto.destroy = function() {
        this.pointerDone();
        this.unbindTap();
    };

// -----  ----- //

    return TapListener;

}));

// prev/next buttons
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/prev-next-button',[
            './flickity',
            'tap-listener/tap-listener',
            'fizzy-ui-utils/utils'
        ], function( Flickity, TapListener, utils ) {
            return factory( window, Flickity, TapListener, utils );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('./flickity'),
            require('tap-listener'),
            require('fizzy-ui-utils')
        );
    } else {
        // browser global
        factory(
            window,
            window.Flickity,
            window.TapListener,
            window.fizzyUIUtils
        );
    }

}( window, function factory( window, Flickity, TapListener, utils ) {
    'use strict';

    var svgURI = 'http://www.w3.org/2000/svg';

// -------------------------- PrevNextButton -------------------------- //

    function PrevNextButton( direction, parent ) {
        this.direction = direction;
        this.parent = parent;
        this._create();
    }

    PrevNextButton.prototype = new TapListener();

    PrevNextButton.prototype._create = function() {
        // properties
        this.isEnabled = true;
        this.isPrevious = this.direction == -1;
        var leftDirection = this.parent.options.rightToLeft ? 1 : -1;
        this.isLeft = this.direction == leftDirection;

        var element = this.element = document.createElement('button');
        element.className = 'flickity-prev-next-button';
        element.className += this.isPrevious ? ' previous' : ' next';
        // prevent button from submitting form http://stackoverflow.com/a/10836076/182183
        element.setAttribute( 'type', 'button' );
        // init as disabled
        this.disable();

        element.setAttribute( 'aria-label', this.isPrevious ? 'previous' : 'next' );

        // create arrow
        var svg = this.createSVG();
        element.appendChild( svg );
        // update on select
        this.parent.on( 'select', function() {
            this.update();
        }.bind( this ));
        // tap
        this.on( 'tap', this.onTap );
        // pointerDown
        this.on( 'pointerDown', function onPointerDown( button, event ) {
            this.parent.childUIPointerDown( event );
        }.bind( this ));
    };

    PrevNextButton.prototype.activate = function() {
        this.bindTap( this.element );
        // click events from keyboard
        this.element.addEventListener( 'click', this );
        // add to DOM
        this.parent.element.appendChild( this.element );
    };

    PrevNextButton.prototype.deactivate = function() {
        // remove from DOM
        this.parent.element.removeChild( this.element );
        // do regular TapListener destroy
        TapListener.prototype.destroy.call( this );
        // click events from keyboard
        this.element.removeEventListener( 'click', this );
    };

    PrevNextButton.prototype.createSVG = function() {
        var svg = document.createElementNS( svgURI, 'svg');
        svg.setAttribute( 'viewBox', '0 0 100 100' );
        var path = document.createElementNS( svgURI, 'path');
        var pathMovements = getArrowMovements( this.parent.options.arrowShape );
        path.setAttribute( 'd', pathMovements );
        path.setAttribute( 'class', 'arrow' );
        // rotate arrow
        if ( !this.isLeft ) {
            path.setAttribute( 'transform', 'translate(100, 100) rotate(180) ' );
        }
        svg.appendChild( path );
        return svg;
    };

// get SVG path movmement
    function getArrowMovements( shape ) {
        // use shape as movement if string
        if ( typeof shape == 'string' ) {
            return shape;
        }
        // create movement string
        return 'M ' + shape.x0 + ',50' +
            ' L ' + shape.x1 + ',' + ( shape.y1 + 50 ) +
            ' L ' + shape.x2 + ',' + ( shape.y2 + 50 ) +
            ' L ' + shape.x3 + ',50 ' +
            ' L ' + shape.x2 + ',' + ( 50 - shape.y2 ) +
            ' L ' + shape.x1 + ',' + ( 50 - shape.y1 ) +
            ' Z';
    }

    PrevNextButton.prototype.onTap = function() {
        if ( !this.isEnabled ) {
            return;
        }
        this.parent.uiChange();
        var method = this.isPrevious ? 'previous' : 'next';
        this.parent[ method ]();
    };

    PrevNextButton.prototype.handleEvent = utils.handleEvent;

    PrevNextButton.prototype.onclick = function() {
        // only allow clicks from keyboard
        var focused = document.activeElement;
        if ( focused && focused == this.element ) {
            this.onTap();
        }
    };

// -----  ----- //

    PrevNextButton.prototype.enable = function() {
        if ( this.isEnabled ) {
            return;
        }
        this.element.disabled = false;
        this.isEnabled = true;
    };

    PrevNextButton.prototype.disable = function() {
        if ( !this.isEnabled ) {
            return;
        }
        this.element.disabled = true;
        this.isEnabled = false;
    };

    PrevNextButton.prototype.update = function() {
        // index of first or last slide, if previous or next
        var slides = this.parent.slides;
        // enable is wrapAround and at least 2 slides
        if ( this.parent.options.wrapAround && slides.length > 1 ) {
            this.enable();
            return;
        }
        var lastIndex = slides.length ? slides.length - 1 : 0;
        var boundIndex = this.isPrevious ? 0 : lastIndex;
        var method = this.parent.selectedIndex == boundIndex ? 'disable' : 'enable';
        this[ method ]();
    };

    PrevNextButton.prototype.destroy = function() {
        this.deactivate();
    };

// -------------------------- Flickity prototype -------------------------- //

    utils.extend( Flickity.defaults, {
        prevNextButtons: false,
        arrowShape: {
            x0: 10,
            x1: 60, y1: 50,
            x2: 70, y2: 40,
            x3: 30
        }
    });

    Flickity.createMethods.push('_createPrevNextButtons');
    var proto = Flickity.prototype;

    proto._createPrevNextButtons = function() {
        if ( !this.options.prevNextButtons ) {
            return;
        }

        this.prevButton = new PrevNextButton( -1, this );
        this.nextButton = new PrevNextButton( 1, this );

        this.on( 'activate', this.activatePrevNextButtons );
    };

    proto.activatePrevNextButtons = function() {
        this.prevButton.activate();
        this.nextButton.activate();
        this.on( 'deactivate', this.deactivatePrevNextButtons );
    };

    proto.deactivatePrevNextButtons = function() {
        this.prevButton.deactivate();
        this.nextButton.deactivate();
        this.off( 'deactivate', this.deactivatePrevNextButtons );
    };

// --------------------------  -------------------------- //

    Flickity.PrevNextButton = PrevNextButton;

    return Flickity;

}));

// page dots
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/page-dots',[
            './flickity',
            'tap-listener/tap-listener',
            'fizzy-ui-utils/utils'
        ], function( Flickity, TapListener, utils ) {
            return factory( window, Flickity, TapListener, utils );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('./flickity'),
            require('tap-listener'),
            require('fizzy-ui-utils')
        );
    } else {
        // browser global
        factory(
            window,
            window.Flickity,
            window.TapListener,
            window.fizzyUIUtils
        );
    }

}( window, function factory( window, Flickity, TapListener, utils ) {

// -------------------------- PageDots -------------------------- //



    function PageDots( parent ) {
        this.parent = parent;
        this._create();
    }

    PageDots.prototype = new TapListener();

    PageDots.prototype._create = function() {
        // create holder element
        this.holder = document.createElement('ol');
        this.holder.className = 'flickity-page-dots';
        // create dots, array of elements
        this.dots = [];
        // tap
        this.on( 'tap', this.onTap );

    };

    PageDots.prototype.activate = function() {
        this.setDots();
        this.bindTap( this.holder );
        // add to DOM
        this.parent.element.appendChild( this.holder );
    };

    PageDots.prototype.deactivate = function() {
        // remove from DOM
        this.parent.element.removeChild( this.holder );
        TapListener.prototype.destroy.call( this );
    };

    PageDots.prototype.setDots = function() {
        // get difference between number of slides and number of dots
        var delta = this.parent.slides.length - this.dots.length;
        if ( delta > 0 ) {
            this.addDots( delta );
        } else if ( delta < 0 ) {
            this.removeDots( -delta );
        }
    };

    PageDots.prototype.addDots = function( count ) {
        var fragment = document.createDocumentFragment();
        var newDots = [];
        while ( count ) {
            var dot = document.createElement('li');
            dot.className = 'dot';
            fragment.appendChild( dot );
            newDots.push( dot );
            count--;
        }
        this.holder.appendChild( fragment );
        this.dots = this.dots.concat( newDots );
    };

    PageDots.prototype.removeDots = function( count ) {
        // remove from this.dots collection
        var removeDots = this.dots.splice( this.dots.length - count, count );
        // remove from DOM
        removeDots.forEach( function( dot ) {
            this.holder.removeChild( dot );
        }, this );
    };

    PageDots.prototype.updateSelected = function() {
        // remove selected class on previous
        if ( this.selectedDot ) {
            this.selectedDot.className = 'dot';
        }
        // don't proceed if no dots
        if ( !this.dots.length ) {
            return;
        }
        this.selectedDot = this.dots[ this.parent.selectedIndex ];
        this.selectedDot.className = 'dot is-selected';
    };

    PageDots.prototype.onTap = function( event ) {
        var target = event.target;
        // only care about dot clicks
        if ( target.nodeName != 'LI' ) {
            return;
        }

        this.parent.uiChange();
        var index = this.dots.indexOf( target );
        this.parent.select( index );
    };

    PageDots.prototype.destroy = function() {
        this.deactivate();
    };

    Flickity.PageDots = PageDots;

// -------------------------- Flickity -------------------------- //

    utils.extend( Flickity.defaults, {
        pageDots: false
    });

    Flickity.createMethods.push('_createPageDots');

    var proto = Flickity.prototype;

    proto._createPageDots = function() {
        if ( !this.options.pageDots ) {
            return;
        }
        this.pageDots = new PageDots( this );
        // events
        this.on( 'activate', this.activatePageDots );
        this.on( 'select', this.updateSelectedPageDots );
        this.on( 'cellChange', this.updatePageDots );
        this.on( 'resize', this.updatePageDots );
        this.on( 'deactivate', this.deactivatePageDots );

        this.pageDots.on( 'pointerDown', function( button, event ) {
            this.childUIPointerDown( event );
        }.bind( this ));
    };

    proto.activatePageDots = function() {
        this.pageDots.activate();
    };

    proto.updateSelectedPageDots = function() {
        this.pageDots.updateSelected();
    };

    proto.updatePageDots = function() {
        this.pageDots.setDots();
    };

    proto.deactivatePageDots = function() {
        this.pageDots.deactivate();
    };

// -----  ----- //

    Flickity.PageDots = PageDots;

    return Flickity;

}));

// player & autoPlay
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/player',[
            'ev-emitter/ev-emitter',
            'fizzy-ui-utils/utils',
            './flickity'
        ], function( EvEmitter, utils, Flickity ) {
            return factory( EvEmitter, utils, Flickity );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            require('ev-emitter'),
            require('fizzy-ui-utils'),
            require('./flickity')
        );
    } else {
        // browser global
        factory(
            window.EvEmitter,
            window.fizzyUIUtils,
            window.Flickity
        );
    }

}( window, function factory( EvEmitter, utils, Flickity ) {



// -------------------------- Page Visibility -------------------------- //
// https://developer.mozilla.org/en-US/docs/Web/Guide/User_experience/Using_the_Page_Visibility_API

    var hiddenProperty, visibilityEvent;
    if ( 'hidden' in document ) {
        hiddenProperty = 'hidden';
        visibilityEvent = 'visibilitychange';
    } else if ( 'webkitHidden' in document ) {
        hiddenProperty = 'webkitHidden';
        visibilityEvent = 'webkitvisibilitychange';
    }

// -------------------------- Player -------------------------- //

    function Player( parent ) {
        this.parent = parent;
        this.state = 'stopped';
        // visibility change event handler
        if ( visibilityEvent ) {
            this.onVisibilityChange = function() {
                this.visibilityChange();
            }.bind( this );
            this.onVisibilityPlay = function() {
                this.visibilityPlay();
            }.bind( this );
        }
    }

    Player.prototype = Object.create( EvEmitter.prototype );

// start play
    Player.prototype.play = function() {
        if ( this.state == 'playing' ) {
            return;
        }
        // do not play if page is hidden, start playing when page is visible
        var isPageHidden = document[ hiddenProperty ];
        if ( visibilityEvent && isPageHidden ) {
            document.addEventListener( visibilityEvent, this.onVisibilityPlay );
            return;
        }

        this.state = 'playing';
        // listen to visibility change
        if ( visibilityEvent ) {
            document.addEventListener( visibilityEvent, this.onVisibilityChange );
        }
        // start ticking
        this.tick();
    };

    Player.prototype.tick = function() {
        // do not tick if not playing
        if ( this.state != 'playing' ) {
            return;
        }

        var time = this.parent.options.autoPlay;
        // default to 3 seconds
        time = typeof time == 'number' ? time : 3000;
        var _this = this;
        // HACK: reset ticks if stopped and started within interval
        this.clear();
        this.timeout = setTimeout( function() {
            _this.parent.next( true );
            _this.tick();
        }, time );
    };

    Player.prototype.stop = function() {
        this.state = 'stopped';
        this.clear();
        // remove visibility change event
        if ( visibilityEvent ) {
            document.removeEventListener( visibilityEvent, this.onVisibilityChange );
        }
    };

    Player.prototype.clear = function() {
        clearTimeout( this.timeout );
    };

    Player.prototype.pause = function() {
        if ( this.state == 'playing' ) {
            this.state = 'paused';
            this.clear();
        }
    };

    Player.prototype.unpause = function() {
        // re-start play if paused
        if ( this.state == 'paused' ) {
            this.play();
        }
    };

// pause if page visibility is hidden, unpause if visible
    Player.prototype.visibilityChange = function() {
        var isPageHidden = document[ hiddenProperty ];
        this[ isPageHidden ? 'pause' : 'unpause' ]();
    };

    Player.prototype.visibilityPlay = function() {
        this.play();
        document.removeEventListener( visibilityEvent, this.onVisibilityPlay );
    };

// -------------------------- Flickity -------------------------- //

    utils.extend( Flickity.defaults, {
        pauseAutoPlayOnHover: true
    });

    Flickity.createMethods.push('_createPlayer');
    var proto = Flickity.prototype;

    proto._createPlayer = function() {
        this.player = new Player( this );

        this.on( 'activate', this.activatePlayer );
        this.on( 'uiChange', this.stopPlayer );
        this.on( 'pointerDown', this.stopPlayer );
        this.on( 'deactivate', this.deactivatePlayer );
    };

    proto.activatePlayer = function() {
        if ( !this.options.autoPlay ) {
            return;
        }
        this.player.play();
        this.element.addEventListener( 'mouseenter', this );
    };

// Player API, don't hate the ... thanks I know where the door is

    proto.playPlayer = function() {
        this.player.play();
    };

    proto.stopPlayer = function() {
        this.player.stop();
    };

    proto.pausePlayer = function() {
        this.player.pause();
    };

    proto.unpausePlayer = function() {
        this.player.unpause();
    };

    proto.deactivatePlayer = function() {
        this.player.stop();
        this.element.removeEventListener( 'mouseenter', this );
    };

// ----- mouseenter/leave ----- //

// pause auto-play on hover
    proto.onmouseenter = function() {
        if ( !this.options.pauseAutoPlayOnHover ) {
            return;
        }
        this.player.pause();
        this.element.addEventListener( 'mouseleave', this );
    };

// resume auto-play on hover off
    proto.onmouseleave = function() {
        this.player.unpause();
        this.element.removeEventListener( 'mouseleave', this );
    };

// -----  ----- //

    Flickity.Player = Player;

    return Flickity;

}));

// add, remove cell
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/add-remove-cell',[
            './flickity',
            'fizzy-ui-utils/utils'
        ], function( Flickity, utils ) {
            return factory( window, Flickity, utils );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('./flickity'),
            require('fizzy-ui-utils')
        );
    } else {
        // browser global
        factory(
            window,
            window.Flickity,
            window.fizzyUIUtils
        );
    }

}( window, function factory( window, Flickity, utils ) {



// append cells to a document fragment
    function getCellsFragment( cells ) {
        var fragment = document.createDocumentFragment();
        cells.forEach( function( cell ) {
            fragment.appendChild( cell.element );
        });
        return fragment;
    }

// -------------------------- add/remove cell prototype -------------------------- //

    var proto = Flickity.prototype;

    /**
     * Insert, prepend, or append cells
     * @param {Element, Array, NodeList} elems
     * @param {Integer} index
     */
    proto.insert = function( elems, index ) {
        var cells = this._makeCells( elems );
        if ( !cells || !cells.length ) {
            return;
        }
        var len = this.cells.length;
        // default to append
        index = index === undefined ? len : index;
        // add cells with document fragment
        var fragment = getCellsFragment( cells );
        // append to slider
        var isAppend = index == len;
        if ( isAppend ) {
            this.slider.appendChild( fragment );
        } else {
            var insertCellElement = this.cells[ index ].element;
            this.slider.insertBefore( fragment, insertCellElement );
        }
        // add to this.cells
        if ( index === 0 ) {
            // prepend, add to start
            this.cells = cells.concat( this.cells );
        } else if ( isAppend ) {
            // append, add to end
            this.cells = this.cells.concat( cells );
        } else {
            // insert in this.cells
            var endCells = this.cells.splice( index, len - index );
            this.cells = this.cells.concat( cells ).concat( endCells );
        }

        this._sizeCells( cells );

        var selectedIndexDelta = index > this.selectedIndex ? 0 : cells.length;
        this._cellAddedRemoved( index, selectedIndexDelta );
    };

    proto.append = function( elems ) {
        this.insert( elems, this.cells.length );
    };

    proto.prepend = function( elems ) {
        this.insert( elems, 0 );
    };

    /**
     * Remove cells
     * @param {Element, Array, NodeList} elems
     */
    proto.remove = function( elems ) {
        var cells = this.getCells( elems );
        var selectedIndexDelta = 0;
        var len = cells.length;
        var i, cell;
        // calculate selectedIndexDelta, easier if done in seperate loop
        for ( i=0; i < len; i++ ) {
            cell = cells[i];
            var wasBefore = this.cells.indexOf( cell ) < this.selectedIndex;
            selectedIndexDelta -= wasBefore ? 1 : 0;
        }

        for ( i=0; i < len; i++ ) {
            cell = cells[i];
            cell.remove();
            // remove item from collection
            utils.removeFrom( this.cells, cell );
        }

        if ( cells.length ) {
            // update stuff
            this._cellAddedRemoved( 0, selectedIndexDelta );
        }
    };

// updates when cells are added or removed
    proto._cellAddedRemoved = function( changedCellIndex, selectedIndexDelta ) {
        // TODO this math isn't perfect with grouped slides
        selectedIndexDelta = selectedIndexDelta || 0;
        this.selectedIndex += selectedIndexDelta;
        this.selectedIndex = Math.max( 0, Math.min( this.slides.length - 1, this.selectedIndex ) );

        this.cellChange( changedCellIndex, true );
        // backwards compatibility
        this.emitEvent( 'cellAddedRemoved', [ changedCellIndex, selectedIndexDelta ] );
    };

    /**
     * logic to be run after a cell's size changes
     * @param {Element} elem - cell's element
     */
    proto.cellSizeChange = function( elem ) {
        var cell = this.getCell( elem );
        if ( !cell ) {
            return;
        }
        cell.getSize();

        var index = this.cells.indexOf( cell );
        this.cellChange( index );
    };

    /**
     * logic any time a cell is changed: added, removed, or size changed
     * @param {Integer} changedCellIndex - index of the changed cell, optional
     */
    proto.cellChange = function( changedCellIndex, isPositioningSlider ) {
        var prevSlideableWidth = this.slideableWidth;
        this._positionCells( changedCellIndex );
        this._getWrapShiftCells();
        this.setGallerySize();
        this.emitEvent( 'cellChange', [ changedCellIndex ] );
        // position slider
        if ( this.options.freeScroll ) {
            // shift x by change in slideableWidth
            // TODO fix position shifts when prepending w/ freeScroll
            var deltaX = prevSlideableWidth - this.slideableWidth;
            this.x += deltaX * this.cellAlign;
            this.positionSlider();
        } else {
            // do not position slider after lazy load
            if ( isPositioningSlider ) {
                this.positionSliderAtSelected();
            }
            this.select( this.selectedIndex );
        }
    };

// -----  ----- //

    return Flickity;

}));

// lazyload
( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/lazyload',[
            './flickity',
            'fizzy-ui-utils/utils'
        ], function( Flickity, utils ) {
            return factory( window, Flickity, utils );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('./flickity'),
            require('fizzy-ui-utils')
        );
    } else {
        // browser global
        factory(
            window,
            window.Flickity,
            window.fizzyUIUtils
        );
    }

}( window, function factory( window, Flickity, utils ) {
    'use strict';

    Flickity.createMethods.push('_createLazyload');
    var proto = Flickity.prototype;

    proto._createLazyload = function() {
        this.on( 'select', this.lazyLoad );
    };

    proto.lazyLoad = function() {
        var lazyLoad = this.options.lazyLoad;
        if ( !lazyLoad ) {
            return;
        }
        // get adjacent cells, use lazyLoad option for adjacent count
        var adjCount = typeof lazyLoad == 'number' ? lazyLoad : 0;
        var cellElems = this.getAdjacentCellElements( adjCount );
        // get lazy images in those cells
        var lazyImages = [];
        cellElems.forEach( function( cellElem ) {
            var lazyCellImages = getCellLazyImages( cellElem );
            lazyImages = lazyImages.concat( lazyCellImages );
        });
        // load lazy images
        lazyImages.forEach( function( img ) {
            new LazyLoader( img, this );
        }, this );
    };

    function getCellLazyImages( cellElem ) {
        // check if cell element is lazy image
        if ( cellElem.nodeName == 'IMG' &&
            cellElem.getAttribute('data-flickity-lazyload') ) {
            return [ cellElem ];
        }
        // select lazy images in cell
        var imgs = cellElem.querySelectorAll('img[data-flickity-lazyload]');
        return utils.makeArray( imgs );
    }

// -------------------------- LazyLoader -------------------------- //

    /**
     * class to handle loading images
     */
    function LazyLoader( img, flickity ) {
        this.img = img;
        this.flickity = flickity;
        this.load();
    }

    LazyLoader.prototype.handleEvent = utils.handleEvent;

    LazyLoader.prototype.load = function() {
        this.img.addEventListener( 'load', this );
        this.img.addEventListener( 'error', this );
        // load image
        this.img.src = this.img.getAttribute('data-flickity-lazyload');
        // remove attr
        this.img.removeAttribute('data-flickity-lazyload');
    };

    LazyLoader.prototype.onload = function( event ) {
        this.complete( event, 'flickity-lazyloaded' );
    };

    LazyLoader.prototype.onerror = function( event ) {
        this.complete( event, 'flickity-lazyerror' );
    };

    LazyLoader.prototype.complete = function( event, className ) {
        // unbind events
        this.img.removeEventListener( 'load', this );
        this.img.removeEventListener( 'error', this );

        var cell = this.flickity.getParentCell( this.img );
        var cellElem = cell && cell.element;
        this.flickity.cellSizeChange( cellElem );

        this.img.classList.add( className );
        this.flickity.dispatchEvent( 'lazyLoad', event, cellElem );
    };

// -----  ----- //

    Flickity.LazyLoader = LazyLoader;

    return Flickity;

}));

/*!
 * Flickity v2.0.2
 * Touch, responsive, flickable carousels
 *
 * Licensed GPLv3 for open source use
 * or Flickity Commercial License for commercial use
 *
 * http://flickity.metafizzy.co
 * Copyright 2016 Metafizzy
 */

( function( window, factory ) {
    // universal module definition
    /* jshint strict: false */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity/js/index',[
            './flickity',
            './drag',
            './prev-next-button',
            './page-dots',
            './player',
            './add-remove-cell',
            './lazyload'
        ], factory );
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            require('./flickity'),
            require('./drag'),
            require('./prev-next-button'),
            require('./page-dots'),
            require('./player'),
            require('./add-remove-cell'),
            require('./lazyload')
        );
    }

})( window, function factory( Flickity ) {
    /*jshint strict: false*/
    return Flickity;
});

/*!
 * Flickity asNavFor v2.0.0
 * enable asNavFor for Flickity
 */

/*jshint browser: true, undef: true, unused: true, strict: true*/

( function( window, factory ) {
    // universal module definition
    /*jshint strict: false */ /*globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'flickity-as-nav-for/as-nav-for',[
            'flickity/js/index',
            'fizzy-ui-utils/utils'
        ], function( classie, Flickity, utils ) {
            return factory( window, classie, Flickity, utils );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('flickity'),
            require('fizzy-ui-utils')
        );
    } else {
        // browser global
        window.Flickity = factory(
            window,
            window.Flickity,
            window.fizzyUIUtils
        );
    }

}( window, function factory( window, Flickity, utils ) {



// -------------------------- asNavFor prototype -------------------------- //

// Flickity.defaults.asNavFor = null;

    Flickity.createMethods.push('_createAsNavFor');

    var proto = Flickity.prototype;

    proto._createAsNavFor = function() {
        this.on( 'activate', this.activateAsNavFor );
        this.on( 'deactivate', this.deactivateAsNavFor );
        this.on( 'destroy', this.destroyAsNavFor );

        var asNavForOption = this.options.asNavFor;
        if ( !asNavForOption ) {
            return;
        }
        // HACK do async, give time for other flickity to be initalized
        var _this = this;
        setTimeout( function initNavCompanion() {
            _this.setNavCompanion( asNavForOption );
        });
    };

    proto.setNavCompanion = function( elem ) {
        elem = utils.getQueryElement( elem );
        var companion = Flickity.data( elem );
        // stop if no companion or companion is self
        if ( !companion || companion == this ) {
            return;
        }

        this.navCompanion = companion;
        // companion select
        var _this = this;
        this.onNavCompanionSelect = function() {
            _this.navCompanionSelect();
        };
        companion.on( 'select', this.onNavCompanionSelect );
        // click
        this.on( 'staticClick', this.onNavStaticClick );

        this.navCompanionSelect();
    };

    proto.navCompanionSelect = function() {
        if ( !this.navCompanion ) {
            return;
        }
        // select slide that matches first cell of slide
        var selectedCell = this.navCompanion.selectedCells[0];
        var cellIndex = this.navCompanion.cells.indexOf( selectedCell );
        this.selectCell( cellIndex );
        // set nav selected class
        this.removeNavSelectedElements();
        // stop if companion has more cells than this one
        if ( cellIndex >= this.cells.length ) {
            return;
        }
        this.navSelectedElements = this.slides[ this.selectedIndex ].getCellElements();
        this.changeNavSelectedClass('add');
    };

    proto.changeNavSelectedClass = function( method ) {
        this.navSelectedElements.forEach( function( navElem ) {
            navElem.classList[ method ]('is-nav-selected');
        });
    };

    proto.activateAsNavFor = function() {
        this.navCompanionSelect();
    };

    proto.removeNavSelectedElements = function() {
        if ( !this.navSelectedElements ) {
            return;
        }
        this.changeNavSelectedClass('remove');
        delete this.navSelectedElements;
    };

    proto.onNavStaticClick = function( event, pointer, cellElement, cellIndex ) {
        if ( typeof cellIndex == 'number' ) {
            this.navCompanion.selectCell( cellIndex );
        }
    };

    proto.deactivateAsNavFor = function() {
        this.removeNavSelectedElements();
    };

    proto.destroyAsNavFor = function() {
        if ( !this.navCompanion ) {
            return;
        }
        this.navCompanion.off( 'select', this.onNavCompanionSelect );
        this.off( 'staticClick', this.onNavStaticClick );
        delete this.navCompanion;
    };

// -----  ----- //

    return Flickity;

}));

/*!
 * imagesLoaded v4.1.0
 * JavaScript is all like "You images are done yet or what?"
 * MIT License
 */

( function( window, factory ) { 'use strict';
    // universal module definition

    /*global define: false, module: false, require: false */

    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( 'imagesloaded/imagesloaded',[
            'ev-emitter/ev-emitter'
        ], function( EvEmitter ) {
            return factory( window, EvEmitter );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('ev-emitter')
        );
    } else {
        // browser global
        window.imagesLoaded = factory(
            window,
            window.EvEmitter
        );
    }

})( window,

// --------------------------  factory -------------------------- //

    function factory( window, EvEmitter ) {



        var $ = window.jQuery;
        var console = window.console;

// -------------------------- helpers -------------------------- //

// extend objects
        function extend( a, b ) {
            for ( var prop in b ) {
                a[ prop ] = b[ prop ];
            }
            return a;
        }

// turn element or nodeList into an array
        function makeArray( obj ) {
            var ary = [];
            if ( Array.isArray( obj ) ) {
                // use object if already an array
                ary = obj;
            } else if ( typeof obj.length == 'number' ) {
                // convert nodeList to array
                for ( var i=0; i < obj.length; i++ ) {
                    ary.push( obj[i] );
                }
            } else {
                // array of single index
                ary.push( obj );
            }
            return ary;
        }

// -------------------------- imagesLoaded -------------------------- //

        /**
         * @param {Array, Element, NodeList, String} elem
         * @param {Object or Function} options - if function, use as callback
         * @param {Function} onAlways - callback function
         */
        function ImagesLoaded( elem, options, onAlways ) {
            // coerce ImagesLoaded() without new, to be new ImagesLoaded()
            if ( !( this instanceof ImagesLoaded ) ) {
                return new ImagesLoaded( elem, options, onAlways );
            }
            // use elem as selector string
            if ( typeof elem == 'string' ) {
                elem = document.querySelectorAll( elem );
            }

            this.elements = makeArray( elem );
            this.options = extend( {}, this.options );

            if ( typeof options == 'function' ) {
                onAlways = options;
            } else {
                extend( this.options, options );
            }

            if ( onAlways ) {
                this.on( 'always', onAlways );
            }

            this.getImages();

            if ( $ ) {
                // add jQuery Deferred object
                this.jqDeferred = new $.Deferred();
            }

            // HACK check async to allow time to bind listeners
            setTimeout( function() {
                this.check();
            }.bind( this ));
        }

        ImagesLoaded.prototype = Object.create( EvEmitter.prototype );

        ImagesLoaded.prototype.options = {};

        ImagesLoaded.prototype.getImages = function() {
            this.images = [];

            // filter & find items if we have an item selector
            this.elements.forEach( this.addElementImages, this );
        };

        /**
         * @param {Node} element
         */
        ImagesLoaded.prototype.addElementImages = function( elem ) {
            // filter siblings
            if ( elem.nodeName == 'IMG' ) {
                this.addImage( elem );
            }
            // get background image on element
            if ( this.options.background === true ) {
                this.addElementBackgroundImages( elem );
            }

            // find children
            // no non-element nodes, #143
            var nodeType = elem.nodeType;
            if ( !nodeType || !elementNodeTypes[ nodeType ] ) {
                return;
            }
            var childImgs = elem.querySelectorAll('img');
            // concat childElems to filterFound array
            for ( var i=0; i < childImgs.length; i++ ) {
                var img = childImgs[i];
                this.addImage( img );
            }

            // get child background images
            if ( typeof this.options.background == 'string' ) {
                var children = elem.querySelectorAll( this.options.background );
                for ( i=0; i < children.length; i++ ) {
                    var child = children[i];
                    this.addElementBackgroundImages( child );
                }
            }
        };

        var elementNodeTypes = {
            1: true,
            9: true,
            11: true
        };

        ImagesLoaded.prototype.addElementBackgroundImages = function( elem ) {
            var style = getComputedStyle( elem );
            if ( !style ) {
                // Firefox returns null if in a hidden iframe https://bugzil.la/548397
                return;
            }
            // get url inside url("...")
            var reURL = /url\((['"])?(.*?)\1\)/gi;
            var matches = reURL.exec( style.backgroundImage );
            while ( matches !== null ) {
                var url = matches && matches[2];
                if ( url ) {
                    this.addBackground( url, elem );
                }
                matches = reURL.exec( style.backgroundImage );
            }
        };

        /**
         * @param {Image} img
         */
        ImagesLoaded.prototype.addImage = function( img ) {
            var loadingImage = new LoadingImage( img );
            this.images.push( loadingImage );
        };

        ImagesLoaded.prototype.addBackground = function( url, elem ) {
            var background = new Background( url, elem );
            this.images.push( background );
        };

        ImagesLoaded.prototype.check = function() {
            var _this = this;
            this.progressedCount = 0;
            this.hasAnyBroken = false;
            // complete if no images
            if ( !this.images.length ) {
                this.complete();
                return;
            }

            function onProgress( image, elem, message ) {
                // HACK - Chrome triggers event before object properties have changed. #83
                setTimeout( function() {
                    _this.progress( image, elem, message );
                });
            }

            this.images.forEach( function( loadingImage ) {
                loadingImage.once( 'progress', onProgress );
                loadingImage.check();
            });
        };

        ImagesLoaded.prototype.progress = function( image, elem, message ) {
            this.progressedCount++;
            this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded;
            // progress event
            this.emitEvent( 'progress', [ this, image, elem ] );
            if ( this.jqDeferred && this.jqDeferred.notify ) {
                this.jqDeferred.notify( this, image );
            }
            // check if completed
            if ( this.progressedCount == this.images.length ) {
                this.complete();
            }

            if ( this.options.debug && console ) {
                console.log( 'progress: ' + message, image, elem );
            }
        };

        ImagesLoaded.prototype.complete = function() {
            var eventName = this.hasAnyBroken ? 'fail' : 'done';
            this.isComplete = true;
            this.emitEvent( eventName, [ this ] );
            this.emitEvent( 'always', [ this ] );
            if ( this.jqDeferred ) {
                var jqMethod = this.hasAnyBroken ? 'reject' : 'resolve';
                this.jqDeferred[ jqMethod ]( this );
            }
        };

// --------------------------  -------------------------- //

        function LoadingImage( img ) {
            this.img = img;
        }

        LoadingImage.prototype = Object.create( EvEmitter.prototype );

        LoadingImage.prototype.check = function() {
            // If complete is true and browser supports natural sizes,
            // try to check for image status manually.
            var isComplete = this.getIsImageComplete();
            if ( isComplete ) {
                // report based on naturalWidth
                this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' );
                return;
            }

            // If none of the checks above matched, simulate loading on detached element.
            this.proxyImage = new Image();
            this.proxyImage.addEventListener( 'load', this );
            this.proxyImage.addEventListener( 'error', this );
            // bind to image as well for Firefox. #191
            this.img.addEventListener( 'load', this );
            this.img.addEventListener( 'error', this );
            this.proxyImage.src = this.img.src;
        };

        LoadingImage.prototype.getIsImageComplete = function() {
            return this.img.complete && this.img.naturalWidth !== undefined;
        };

        LoadingImage.prototype.confirm = function( isLoaded, message ) {
            this.isLoaded = isLoaded;
            this.emitEvent( 'progress', [ this, this.img, message ] );
        };

// ----- events ----- //

// trigger specified handler for event type
        LoadingImage.prototype.handleEvent = function( event ) {
            var method = 'on' + event.type;
            if ( this[ method ] ) {
                this[ method ]( event );
            }
        };

        LoadingImage.prototype.onload = function() {
            this.confirm( true, 'onload' );
            this.unbindEvents();
        };

        LoadingImage.prototype.onerror = function() {
            this.confirm( false, 'onerror' );
            this.unbindEvents();
        };

        LoadingImage.prototype.unbindEvents = function() {
            this.proxyImage.removeEventListener( 'load', this );
            this.proxyImage.removeEventListener( 'error', this );
            this.img.removeEventListener( 'load', this );
            this.img.removeEventListener( 'error', this );
        };

// -------------------------- Background -------------------------- //

        function Background( url, element ) {
            this.url = url;
            this.element = element;
            this.img = new Image();
        }

// inherit LoadingImage prototype
        Background.prototype = Object.create( LoadingImage.prototype );

        Background.prototype.check = function() {
            this.img.addEventListener( 'load', this );
            this.img.addEventListener( 'error', this );
            this.img.src = this.url;
            // check if image is already complete
            var isComplete = this.getIsImageComplete();
            if ( isComplete ) {
                this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' );
                this.unbindEvents();
            }
        };

        Background.prototype.unbindEvents = function() {
            this.img.removeEventListener( 'load', this );
            this.img.removeEventListener( 'error', this );
        };

        Background.prototype.confirm = function( isLoaded, message ) {
            this.isLoaded = isLoaded;
            this.emitEvent( 'progress', [ this, this.element, message ] );
        };

// -------------------------- jQuery -------------------------- //

        ImagesLoaded.makeJQueryPlugin = function( jQuery ) {
            jQuery = jQuery || window.jQuery;
            if ( !jQuery ) {
                return;
            }
            // set local variable
            $ = jQuery;
            // $().imagesLoaded()
            $.fn.imagesLoaded = function( options, callback ) {
                var instance = new ImagesLoaded( this, options, callback );
                return instance.jqDeferred.promise( $(this) );
            };
        };
// try making plugin
        ImagesLoaded.makeJQueryPlugin();

// --------------------------  -------------------------- //

        return ImagesLoaded;

    });

/*!
 * Flickity imagesLoaded v2.0.0
 * enables imagesLoaded option for Flickity
 */

/*jshint browser: true, strict: true, undef: true, unused: true */

( function( window, factory ) {
    // universal module definition
    /*jshint strict: false */ /*globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
        // AMD
        define( [
            'flickity/js/index',
            'imagesloaded/imagesloaded'
        ], function( Flickity, imagesLoaded ) {
            return factory( window, Flickity, imagesLoaded );
        });
    } else if ( typeof module == 'object' && module.exports ) {
        // CommonJS
        module.exports = factory(
            window,
            require('flickity'),
            require('imagesloaded')
        );
    } else {
        // browser global
        window.Flickity = factory(
            window,
            window.Flickity,
            window.imagesLoaded
        );
    }

}( window, function factory( window, Flickity, imagesLoaded ) {
    'use strict';

    Flickity.createMethods.push('_createImagesLoaded');

    var proto = Flickity.prototype;

    proto._createImagesLoaded = function() {
        this.on( 'activate', this.imagesLoaded );
    };

    proto.imagesLoaded = function() {
        if ( !this.options.imagesLoaded ) {
            return;
        }
        var _this = this;
        function onImagesLoadedProgress( instance, image ) {
            var cell = _this.getParentCell( image.img );
            _this.cellSizeChange( cell && cell.element );
            if ( !_this.options.freeScroll ) {
                _this.positionSliderAtSelected();
            }
        }
        imagesLoaded( this.slider ).on( 'progress', onImagesLoadedProgress );
    };

    return Flickity;

}));
